imap-backup 5.0.0 → 6.0.0.rc2

data/spec/unit/imap/backup/cli/accounts_spec.rb

@@ -1,8 +1,9 @@
 require "imap/backup/cli/accounts"
 
 describe Imap::Backup::CLI::Accounts do
-  subject { described_class.new }
+  subject { described_class.new(required_accounts) }
 
+  let(:required_accounts) { [] }
   let(:accounts) { [account1, account2] }
   let(:account1) do
     instance_double(
@@ -43,5 +44,15 @@ describe Imap::Backup::CLI::Accounts do
         end.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)
       end
     end
+
+    context "when an account list is provided" do
+      let(:required_accounts) { %w(a2@example.com) }
+
+      specify "calls the block with each account" do
+        result = subject.map { |a| a }
+
+        expect(result).to eq([account2])
+      end
+    end
   end
 end

data/spec/unit/imap/backup/cli/backup_spec.rb

@@ -0,0 +1,19 @@
+module Imap::Backup
+  describe CLI::Backup do
+    subject { described_class.new({}) }
+
+    let(:connection) { instance_double(Account::Connection, run_backup: nil) }
+
+    before do
+      # rubocop:disable RSpec/SubjectStub
+      allow(subject).to receive(:each_connection).with([]).and_yield(connection)
+      # rubocop:enable RSpec/SubjectStub
+    end
+
+    it "runs the backup for each connection" do
+      subject.run
+
+      expect(connection).to have_received(:run_backup)
+    end
+  end
+end

data/spec/unit/imap/backup/cli/folders_spec.rb

@@ -0,0 +1,39 @@
+module Imap::Backup
+  describe CLI::Folders do
+    subject { described_class.new({}) }
+
+    let(:connection) do
+      instance_double(
+        Account::Connection, account: account, folder_names: folder_names
+      )
+    end
+    let(:account) { instance_double(Account, username: "user") }
+    let(:folder_names) { ["my-folder"] }
+
+    before do
+      allow(Kernel).to receive(:puts)
+      allow(Kernel).to receive(:warn)
+      # rubocop:disable RSpec/SubjectStub
+      allow(subject).to receive(:each_connection).with([]).and_yield(connection)
+      # rubocop:enable RSpec/SubjectStub
+
+      subject.run
+    end
+
+    it "lists folders" do
+      expect(Kernel).to have_received(:puts).with("\tmy-folder")
+    end
+
+    context "when the folder list is not fetched" do
+      let(:folder_names) { nil }
+
+      it "warns" do
+        expect(Kernel).to have_received(:warn).with(/Unable to list/)
+      end
+
+      it "doesn't fail" do
+        subject.run
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/cli/local_spec.rb

@@ -23,20 +23,22 @@ describe Imap::Backup::CLI::Local do
   let(:folder) { instance_double(Imap::Backup::Account::Folder, name: "bar") }
   let(:serializer) do
     instance_double(
-      Imap::Backup::Serializer::Mbox,
+      Imap::Backup::Serializer,
       uids: uids,
-      each_message: [[123, message]]
+      each_message: each_message
     )
   end
   let(:uids) { ["123"] }
+  let(:each_message) { [[123, message]] }
   let(:message) do
     instance_double(
       Email::Mboxrd::Message,
       date: Date.today,
-      subject: "Ciao",
+      subject: message_subject,
       supplied_body: "Supplied"
     )
   end
+  let(:message_subject) { "Ciao" }
   let(:email) { "foo@example.com" }
 
   before do
@@ -64,18 +66,35 @@ describe Imap::Backup::CLI::Local do
   end
 
   describe "list" do
-    it "lists downloaded emails" do
-      subject.list(email, "bar")
+    before { subject.list(email, "bar") }
 
+    it "lists downloaded emails" do
       expect(Kernel).to have_received(:puts).with(/Ciao/)
     end
+
+    context "when the subject line is too long" do
+      let(:message_subject) { "A" * 70 }
+
+      it "is shortened" do
+        expect(Kernel).to have_received(:puts).with(/\sA{57}\.\.\./)
+      end
+    end
   end
 
   describe "show" do
-    it "prints a downloaded email" do
-      subject.show(email, "bar", "123")
+    before { subject.show(email, "bar", uids.join(",")) }
 
+    it "prints a downloaded email" do
       expect(Kernel).to have_received(:puts).with("Supplied")
     end
+
+    context "when more than one email is requested" do
+      let(:uids) { %w(123 456) }
+      let(:each_message) { [[123, message], [456, message]] }
+
+      it "prints a header" do
+        expect(Kernel).to have_received(:puts).with(/\| UID: 123 /)
+      end
+    end
   end
 end

data/spec/unit/imap/backup/cli/migrate_spec.rb

@@ -0,0 +1,80 @@
+module Imap::Backup
+  describe CLI::Migrate do
+    subject { described_class.new(source, destination, **options) }
+
+    let(:source) { "source" }
+    let(:destination) { "destination" }
+    let(:options) { {} }
+    let(:config) { instance_double(Configuration, accounts: [account1, account2]) }
+    let(:account1) { instance_double(Account, username: "source", local_path: "path") }
+    let(:account2) { instance_double(Account, username: "destination", connection: connection) }
+    let(:connection) { instance_double(Account::Connection) }
+    let(:migrator) { instance_double(Migrator, run: nil) }
+    let(:imap_pathname) { Pathname.new("path/foo.imap") }
+
+    before do
+      allow(Configuration).to receive(:new) { config }
+      allow(Pathname).to receive(:glob).and_yield(imap_pathname)
+      allow(Migrator).to receive(:new) { migrator }
+      allow(Account::Folder).to receive(:new).and_call_original
+    end
+
+    it "migrates each folder" do
+      subject.run
+
+      expect(migrator).to have_received(:run)
+    end
+
+    context "when source and destination emails are the same" do
+      let(:destination) { "source" }
+
+      it "fails" do
+        expect do
+          subject.run
+        end.to raise_error(RuntimeError, /cannot be the same/)
+      end
+    end
+
+    context "when the source account is not found" do
+      let(:source) { "unknown" }
+
+      it "fails" do
+        expect do
+          subject.run
+        end.to raise_error(RuntimeError, /does not exist/)
+      end
+    end
+
+    context "when the destination account is not found" do
+      let(:destination) { "unknown" }
+
+      it "fails" do
+        expect do
+          subject.run
+        end.to raise_error(RuntimeError, /does not exist/)
+      end
+    end
+
+    context "when source_prefix is supplied" do
+      let(:options) { {source_prefix: "src/"} }
+      let(:imap_pathname) { Pathname.new("path/src/foo.imap") }
+
+      it "removes the prefix" do
+        subject.run
+
+        expect(Account::Folder).to have_received(:new).with(anything, "foo")
+      end
+    end
+
+    context "when destination_prefix is supplied" do
+      let(:options) { {destination_prefix: "dest/"} }
+      let(:imap_pathname) { Pathname.new("path/foo.imap") }
+
+      it "removes the prefix" do
+        subject.run
+
+        expect(Account::Folder).to have_received(:new).with(anything, "dest/foo")
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/cli/restore_spec.rb

@@ -0,0 +1,67 @@
+# rubocop:disable RSpec/SubjectStub
+module Imap::Backup
+  describe CLI::Restore do
+    subject { described_class.new(email, options) }
+
+    let(:connection) { instance_double(Account::Connection, restore: nil) }
+
+    describe "#run" do
+      context "when an email is provided" do
+        let(:email) { "email" }
+        let(:options) { {} }
+
+        before do
+          allow(subject).to receive(:connection).with(email) { connection }
+
+          subject.run
+        end
+
+        it "runs restore on the account" do
+          expect(connection).to have_received(:restore)
+        end
+      end
+
+      context "when neither an email nor a list of account names is provided" do
+        let(:email) { nil }
+        let(:options) { {} }
+
+        before do
+          allow(subject).to receive(:each_connection).with([]).and_yield(connection)
+
+          subject.run
+        end
+
+        it "runs restore on each account" do
+          expect(connection).to have_received(:restore)
+        end
+      end
+
+      context "when an email and a list of account names is provided" do
+        let(:email) { "email" }
+        let(:options) { {accounts: "email2"} }
+
+        it "fails" do
+          expect do
+            subject.run
+          end.to raise_error(RuntimeError, /Pass either an email or the --accounts option/)
+        end
+      end
+
+      context "when just a list of account names is provided" do
+        let(:email) { nil }
+        let(:options) { {accounts: "email2"} }
+
+        before do
+          allow(subject).to receive(:each_connection).with(["email2"]).and_yield(connection)
+
+          subject.run
+        end
+
+        it "runs restore on each account" do
+          expect(connection).to have_received(:restore)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/SubjectStub

data/spec/unit/imap/backup/cli/setup_spec.rb

@@ -0,0 +1,17 @@
+module Imap::Backup
+  describe CLI::Setup do
+    subject { described_class.new }
+
+    let(:setup) { instance_double(Setup, run: nil) }
+
+    before do
+      allow(Setup).to receive(:new) { setup }
+    end
+
+    it "reruns the setup process" do
+      subject.run
+
+      expect(setup).to have_received(:run)
+    end
+  end
+end

data/spec/unit/imap/backup/cli/utils_spec.rb

@@ -11,7 +11,8 @@ module Imap::Backup
       instance_double(
         Account::Connection,
         account: account,
-        backup_folders: [folder]
+        backup_folders: [folder],
+        local_folders: ["folder"]
       )
     end
     let(:account) do
@@ -31,18 +32,80 @@ module Imap::Backup
     end
     let(:serializer) do
       instance_double(
-        Serializer::Mbox,
+        Serializer,
         uids: %w(123 789),
         apply_uid_validity: nil,
-        save: nil
+        append: nil
       )
     end
+    let(:exporter) { instance_double(Thunderbird::MailboxExporter, run: nil) }
     let(:email) { "foo@example.com" }
 
     before do
       allow(CLI::Accounts).to receive(:new) { accounts }
       allow(Account::Connection).to receive(:new) { connection }
-      allow(Serializer::Mbox).to receive(:new) { serializer }
+      allow(Serializer).to receive(:new) { serializer }
+    end
+
+    describe "#export_to_thunderbird" do
+      let(:command) { subject.export_to_thunderbird(email) }
+      let(:options) { {} }
+      let(:profiles) { instance_double(Thunderbird::Profiles, installs: installs, profile: named_profile) }
+      let(:installs) { [install1] }
+      let(:install1) { instance_double(Thunderbird::Install, default: default_install) }
+      let(:default_install) { "default" }
+      let(:named_profile) { "named" }
+
+      before do
+        allow(Thunderbird::MailboxExporter).to receive(:new) { exporter }
+        allow(Thunderbird::Profiles).to receive(:new) { profiles }
+        # rubocop:disable RSpec/SubjectStub
+        allow(subject).to receive(:options) { options }
+        # rubocop:enable RSpec/SubjectStub
+      end
+
+      context "when no profile_name is supplied" do
+        context "when no default Thunderbird profile is found" do
+          let(:default_install) { nil }
+
+          it "fails" do
+            expect do
+              command
+            end.to raise_error(RuntimeError, /Default .*? not found/)
+          end
+        end
+
+        context "when there is more than one install" do
+          let(:installs) { [install1, install2] }
+          let(:install2) { instance_double(Thunderbird::Install, default: default_install) }
+
+          it "fails" do
+            expect do
+              command
+            end.to raise_error(RuntimeError, /multiple installs.*?supply a profile name/m)
+          end
+        end
+      end
+
+      context "when a profile_name is supplied" do
+        let(:options) { {"profile" => "profile"} }
+
+        context "when the supplied profile_name is not found" do
+          let(:named_profile) { nil }
+
+          it "fails" do
+            expect do
+              command
+            end.to raise_error(RuntimeError, /profile 'profile' not found/)
+          end
+        end
+      end
+
+      it "exports the profile" do
+        command
+
+        expect(exporter).to have_received(:run)
+      end
     end
 
     describe "ignore_history" do
@@ -55,7 +118,7 @@ module Imap::Backup
       it "fills the local folder with fake emails" do
         subject.ignore_history(email)
 
-        expect(serializer).to have_received(:save).with("456", /From: fake@email.com/)
+        expect(serializer).to have_received(:append).with("456", /From: fake@email.com/)
       end
     end
   end

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

@@ -0,0 +1,93 @@
+module Imap::Backup
+  RSpec.describe CLI do
+    describe ".exit_on_failure?" do
+      it "is true" do
+        expect(described_class.exit_on_failure?).to be true
+      end
+    end
+
+    describe "#backup" do
+      let(:backup) { instance_double(CLI::Backup, run: nil) }
+
+      before do
+        allow(CLI::Backup).to receive(:new) { backup }
+
+        subject.backup
+      end
+
+      it "runs Backup" do
+        expect(backup).to have_received(:run)
+      end
+    end
+
+    describe "#folders" do
+      let(:folders) { instance_double(CLI::Folders, run: nil) }
+
+      before do
+        allow(CLI::Folders).to receive(:new) { folders }
+
+        subject.folders
+      end
+
+      it "runs folders" do
+        expect(folders).to have_received(:run)
+      end
+    end
+
+    describe "#migrate" do
+      let(:migrate) { instance_double(CLI::Migrate, run: nil) }
+
+      before do
+        allow(CLI::Migrate).to receive(:new) { migrate }
+
+        subject.migrate("source", "destination")
+      end
+
+      it "runs migrate" do
+        expect(migrate).to have_received(:run)
+      end
+    end
+
+    describe "#restore" do
+      let(:restore) { instance_double(CLI::Restore, run: nil) }
+
+      before do
+        allow(CLI::Restore).to receive(:new) { restore }
+
+        subject.restore
+      end
+
+      it "runs restore" do
+        expect(restore).to have_received(:run)
+      end
+    end
+
+    describe "#setup" do
+      let(:setup) { instance_double(CLI::Setup, run: nil) }
+
+      before do
+        allow(CLI::Setup).to receive(:new) { setup }
+
+        subject.setup
+      end
+
+      it "runs setup" do
+        expect(setup).to have_received(:run)
+      end
+    end
+
+    describe "#status" do
+      let(:status) { instance_double(CLI::Status, run: nil) }
+
+      before do
+        allow(CLI::Status).to receive(:new) { status }
+
+        subject.status
+      end
+
+      it "runs status" do
+        expect(status).to have_received(:run)
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/client/apple_mail_spec.rb

@@ -0,0 +1,9 @@
+module Imap::Backup
+  RSpec.describe Client::AppleMail do
+    describe "#provider_root" do
+      it "is an empty string" do
+        expect(subject.provider_root).to eq("")
+      end
+    end
+  end
+end

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

@@ -59,7 +59,7 @@ describe Imap::Backup::Configuration do
     end
 
     context "with accounts flagged 'delete'" do
-      before { subject.accounts[0].mark_for_deletion! }
+      before { subject.accounts[0].mark_for_deletion }
 
       it "is true" do
         expect(subject.modified?).to be_truthy
@@ -177,7 +177,7 @@ describe Imap::Backup::Configuration do
       before do
         allow(subject.accounts[0]).to receive(:to_h) { "Account1" }
         allow(subject.accounts[1]).to receive(:to_h) { "Account2" }
-        subject.accounts[0].mark_for_deletion!
+        subject.accounts[0].mark_for_deletion
       end
 
       it "does not save them" do

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

@@ -1,6 +1,6 @@
 describe Imap::Backup::Downloader do
   describe "#run" do
-    subject { described_class.new(folder, serializer) }
+    subject { described_class.new(folder, serializer, **options) }
 
     let(:body) { "blah" }
     let(:folder) do
@@ -8,17 +8,19 @@ describe Imap::Backup::Downloader do
         Imap::Backup::Account::Folder,
         fetch_multi: [{uid: "111", body: body}],
         name: "folder",
-        uids: folder_uids
+        uids: remote_uids
       )
     end
-    let(:folder_uids) { %w(111 222 333) }
+    let(:remote_uids) { %w(111 222 333) }
     let(:serializer) do
-      instance_double(Imap::Backup::Serializer::Mbox, save: nil, uids: ["222"])
+      instance_double(Imap::Backup::Serializer, append: nil, uids: local_uids)
     end
+    let(:local_uids) { ["222"] }
+    let(:options) { {} }
 
     context "with fetched messages" do
       specify "are saved" do
-        expect(serializer).to receive(:save).with("111", body)
+        expect(serializer).to receive(:append).with("111", body)
 
         subject.run
       end
@@ -26,7 +28,7 @@ describe Imap::Backup::Downloader do
 
     context "with messages which are already present" do
       specify "are skipped" do
-        expect(serializer).to_not receive(:save).with("222", anything)
+        expect(serializer).to_not receive(:append).with("222", anything)
 
         subject.run
       end
@@ -34,11 +36,61 @@ describe Imap::Backup::Downloader do
 
     context "with failed fetches" do
       specify "are skipped" do
-        allow(folder).to receive(:fetch).with("333") { nil }
-        expect(serializer).to_not receive(:save).with("333", anything)
+        allow(folder).to receive(:fetch_multi) { nil }
+        expect(serializer).to_not receive(:append)
 
         subject.run
       end
     end
+
+    context "when the block size is greater than one" do
+      let(:remote_uids) { %w(111 999) }
+      let(:local_uids) { [] }
+      let(:options) { {multi_fetch_size: 2} }
+
+      context "when the first fetch fails" do
+        before do
+          allow(folder).to receive(:fetch_multi).with(["111", "999"]) { nil }
+          allow(folder).to receive(:fetch_multi).with(["111"]).
+            and_return([{uid: "111", body: body}]).
+            and_return([{uid: "999", body: body}])
+
+          subject.run
+        end
+
+        it "retries fetching messages singly" do
+          expect(serializer).to have_received(:append).with("111", body)
+          expect(serializer).to have_received(:append).with("999", body)
+        end
+      end
+    end
+
+    context "when no body is returned by the fetch" do
+      let(:remote_uids) { %w(111) }
+
+      before do
+        allow(folder).to receive(:fetch_multi).with(["111"]) { [{uid: "111", body: nil}] }
+
+        subject.run
+      end
+
+      it "skips the append" do
+        expect(serializer).to_not have_received(:append)
+      end
+    end
+
+    context "when the UID is not returned by the fetch" do
+      let(:remote_uids) { %w(111) }
+
+      before do
+        allow(folder).to receive(:fetch_multi).with(["111"]) { [{uid: nil, body: body}] }
+
+        subject.run
+      end
+
+      it "skips the append" do
+        expect(serializer).to_not have_received(:append)
+      end
+    end
   end
 end

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

@@ -39,7 +39,7 @@ module Imap::Backup
           expect(described_class.logger.level).to eq(::Logger::Severity::ERROR)
         end
 
-        it "sets the Net::IMAP debug flag" do
+        it "doesn't set the Net::IMAP debug flag" do
           expect(Net::IMAP.debug).to be_a(FalseClass)
         end
       end

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

@@ -4,7 +4,7 @@ module Imap::Backup
   RSpec.describe Migrator do
     subject { described_class.new(serializer, folder, reset: reset) }
 
-    let(:serializer) { instance_double(Serializer::MboxStore, uids: [1]) }
+    let(:serializer) { instance_double(Serializer, uids: [1]) }
     let(:folder) do
       instance_double(
         Account::Folder,