imap-backup 5.2.0 → 6.0.0.rc2

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
@@ -35,10 +37,60 @@ describe Imap::Backup::Downloader do
     context "with failed fetches" do
       specify "are skipped" do
         allow(folder).to receive(:fetch_multi) { nil }
-        expect(serializer).to_not receive(:save)
+        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/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,

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

@@ -0,0 +1,42 @@
+module Imap::Backup
+  describe Sanitizer do
+    require "stringio"
+
+    subject { described_class.new(output) }
+
+    let(:output) { StringIO.new }
+
+    describe "#puts" do
+      it "delegates to output" do
+        subject.puts("x")
+
+        expect(output.string).to eq("x\n")
+      end
+    end
+
+    describe "#write" do
+      it "delegates to output" do
+        subject.write("x")
+
+        expect(output.string).to eq("x")
+      end
+    end
+
+    describe "#print" do
+      it "removes passwords from complete lines of text" do
+        subject.print("C: RUBY99 LOGIN xx) secret!!!!\netc")
+
+        expect(output.string).to eq("C: RUBY99 LOGIN xx) [PASSWORD REDACTED]\n")
+      end
+    end
+
+    describe "#flush" do
+      it "sanitizes remaining text" do
+        subject.print("before\nC: RUBY99 LOGIN xx) secret!!!!")
+        subject.flush
+
+        expect(output.string).to eq("before\nC: RUBY99 LOGIN xx) [PASSWORD REDACTED]\n")
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/serializer/directory_spec.rb

@@ -0,0 +1,37 @@
+module Imap::Backup
+  describe Serializer::Directory do
+    subject { described_class.new("path", "relative") }
+
+    let(:windows) { false }
+
+    before do
+      allow(File).to receive(:directory?) { false }
+      allow(Utils).to receive(:make_folder)
+      allow(OS).to receive(:windows?) { windows }
+      allow(Utils).to receive(:mode) { 0o600 }
+      allow(FileUtils).to receive(:chmod)
+
+      subject.ensure_exists
+    end
+
+    describe "#ensure_exists" do
+      context "when the directory doesn't exist" do
+        it "makes the directory" do
+          expect(Utils).to have_received(:make_folder)
+        end
+      end
+
+      it "sets permissions" do
+        expect(FileUtils).to have_received(:chmod)
+      end
+
+      context "when on Windows" do
+        let(:windows) { true }
+
+        it "doesn't set permissions" do
+          expect(FileUtils).to_not have_received(:chmod)
+        end
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/serializer/imap_spec.rb

@@ -0,0 +1,218 @@
+module Imap::Backup
+  describe Serializer::Imap do
+    subject { described_class.new(folder_path) }
+
+    let(:folder_path) { "folder_path" }
+    let(:pathname) { "folder_path.imap" }
+    let(:exists) { true }
+    let(:existing) { {uid_validity: 99, uids: [42]} }
+    let(:file) { instance_double(File, write: nil) }
+
+    before do
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(pathname) { exists }
+      allow(File).to receive(:open).and_call_original
+      allow(File).to receive(:open).with(pathname, "w").and_yield(file)
+      allow(File).to receive(:read).with(pathname) { existing.to_json }
+    end
+
+    describe "loading the metadata file" do
+      context "when it is malformed" do
+        before do
+          allow(File).to receive(:read).with(pathname).and_raise(JSON::ParserError)
+        end
+
+        it "ignores the file" do
+          subject.uid_validity
+
+          expect(subject.uids).to eq([])
+        end
+      end
+    end
+
+    describe "#append" do
+      context "when the metadata file exists" do
+        before { subject.append(123) }
+
+        it "loads the existing metadata" do
+          expect(subject.uids).to include(42)
+        end
+
+        it "appends the UID" do
+          expect(subject.uids).to include(123)
+        end
+
+        it "saves the file" do
+          expect(file).to have_received(:write).
+            with(/"uids":\[42,123\]/)
+        end
+      end
+
+      context "when the metadata file doesn't exist" do
+        let(:exists) { false }
+
+        context "when the uid_validity is set" do
+          before do
+            subject.uid_validity = 999
+          end
+
+          it "appends the UID" do
+            subject.append(123)
+
+            expect(subject.uids).to include(123)
+          end
+
+          it "saves the file" do
+            subject.append(123)
+
+            expect(file).to have_received(:write).
+              with(/"uids":\[123\]/)
+          end
+        end
+
+        context "when the uid_validity is not set" do
+          it "fails" do
+            expect do
+              subject.append(123)
+            end.to raise_error(RuntimeError, /without a uid_validity/)
+          end
+        end
+      end
+    end
+
+    describe "#exist?" do
+      context "when the metadata file exists" do
+        it "is true" do
+          expect(subject.exist?).to be true
+        end
+      end
+
+      context "when the metadata file doesn't exist" do
+        let(:exists) { false }
+
+        it "is false" do
+          expect(subject.exist?).to be false
+        end
+      end
+    end
+
+    describe "#include?" do
+      it "loads the existing metadata" do
+        subject.include?(42)
+
+        expect(File).to have_received(:read).with(pathname)
+      end
+
+      context "when there is a matching UID" do
+        it "is true" do
+          expect(subject.include?(42)).to be true
+        end
+      end
+
+      context "when there isn't a matching UID" do
+        it "is false" do
+          expect(subject.include?(99)).to be false
+        end
+      end
+    end
+
+    describe "#index" do
+      it "loads the existing metadata" do
+        subject.include?(42)
+
+        expect(File).to have_received(:read).with(pathname)
+      end
+
+      context "when there is a matching UID" do
+        it "returns the index of the matcing UID" do
+          expect(subject.index(42)).to eq(0)
+        end
+      end
+
+      context "when there isn't a matching UID" do
+        it "is nil" do
+          expect(subject.index(99)).to be nil
+        end
+      end
+    end
+
+    describe "#rename" do
+      before do
+        allow(File).to receive(:rename)
+
+        subject.rename("new_path")
+      end
+
+      context "when the metadata file exists" do
+        it "sets the folder_path" do
+          expect(subject.folder_path).to eq("new_path")
+        end
+
+        it "renames the metadata file" do
+          expect(File).to have_received(:rename).with(pathname, "new_path.imap")
+        end
+      end
+
+      context "when the metadata file doesn't exist" do
+        let(:exists) { false }
+
+        it "sets the folder_path" do
+          expect(subject.folder_path).to eq("new_path")
+        end
+
+        it "doesn't try to rename the metadata file" do
+          expect(File).to_not have_received(:rename)
+        end
+      end
+    end
+
+    describe "#uid_validity" do
+      it "returns the uid_validity" do
+        expect(subject.uid_validity).to eq(99)
+      end
+    end
+
+    describe "#uid_validity=" do
+      before { subject.uid_validity = 567 }
+
+      it "updates the uid_validity" do
+        expect(subject.uid_validity).to eq(567)
+      end
+
+      it "saves the file" do
+        expect(file).to have_received(:write).
+          with(/"uid_validity":567/)
+      end
+
+      context "when no metadata file exists" do
+        let(:exists) { false }
+
+        it "saves an empty list of UIDs" do
+          expect(file).to have_received(:write).
+            with(/"uids":\[\]/)
+        end
+      end
+    end
+
+    describe "#update_uid" do
+      before { subject.update_uid(42, 57) }
+
+      it "sets the UID" do
+        expect(subject.uids).to eq([57])
+      end
+
+      it "saves the file" do
+        expect(file).to have_received(:write).
+          with(/"uids":\[57\]/)
+      end
+
+      context "when the UID is not present" do
+        let(:existing) { {uid_validity: 99, uids: [2]} }
+
+        it "doesn't save the file" do
+          expect(file).to_not have_received(:write)
+        end
+      end
+    end
+  end
+end