imap-backup 5.2.0 → 6.0.0.rc2

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

@@ -0,0 +1,246 @@
+module Imap::Backup
+  describe Account do
+    subject { described_class.new(options) }
+
+    let(:options) { {username: "user", password: "pwd"} }
+
+    describe "#changes" do
+      it "lists changes" do
+        subject.username = "new"
+
+        expect(subject.changes).to eq(username: {from: "user", to: "new"})
+      end
+
+      context "when more than one change is made" do
+        it "retains the last one" do
+          subject.username = "first"
+          subject.username = "second"
+
+          expect(subject.changes).to eq(username: {from: "user", to: "second"})
+        end
+      end
+
+      context "when a value is reset to its original value" do
+        it "removes the change" do
+          subject.username = "changed"
+          subject.username = "user"
+
+          expect(subject.changes).to eq({})
+        end
+      end
+    end
+
+    describe "#connection" do
+      it "returns a Connection for the Account" do
+        result = subject.connection
+
+        expect(result).to be_a(Account::Connection)
+        expect(result.account).to be subject
+      end
+    end
+
+    describe "#valid?" do
+      context "with username and password" do
+        it "is true" do
+          expect(subject.valid?).to be true
+        end
+      end
+
+      context "without a username" do
+        let(:options) { {password: "pwd"} }
+
+        it "is false" do
+          expect(subject.valid?).to be false
+        end
+      end
+
+      context "without a password" do
+        let(:options) { {username: "user"} }
+
+        it "is false" do
+          expect(subject.valid?).to be false
+        end
+      end
+    end
+
+    describe "#modified?" do
+      context "with changes" do
+        it "is true" do
+          subject.username = "new"
+
+          expect(subject.modified?).to be true
+        end
+      end
+
+      context "without changes" do
+        it "is false" do
+          expect(subject.modified?).to be false
+        end
+      end
+    end
+
+    describe "#clear_changes" do
+      it "clears changes" do
+        subject.username = "new"
+        subject.clear_changes
+
+        expect(subject.changes).to eq({})
+      end
+    end
+
+    describe "#mark_for_deletion" do
+      it "sets marked_for_deletion" do
+        subject.mark_for_deletion
+
+        expect(subject.marked_for_deletion?).to be true
+      end
+    end
+
+    describe "#marked_for_deletion?" do
+      it "defaults to false" do
+        expect(subject.marked_for_deletion?).to be false
+      end
+    end
+
+    describe "#to_h" do
+      it "returns a Hash representation" do
+        expect(subject.to_h).to eq({username: "user", password: "pwd"})
+      end
+
+      context "when local_path is set" do
+        let(:options) { {username: "user", password: "pwd", local_path: "local_path"} }
+
+        it "includes local_path" do
+          expect(subject.to_h).to include({local_path: "local_path"})
+        end
+      end
+
+      context "when folders is set" do
+        let(:options) { {username: "user", password: "pwd", folders: ["folder"]} }
+
+        it "includes folders" do
+          expect(subject.to_h).to include({folders: ["folder"]})
+        end
+      end
+
+      context "when multi_fetch_size is set" do
+        let(:options) { {username: "user", password: "pwd", multi_fetch_size: "3"} }
+
+        it "includes multi_fetch_size" do
+          expect(subject.to_h).to include({multi_fetch_size: 3})
+        end
+      end
+
+      context "when server is set" do
+        let(:options) { {username: "user", password: "pwd", server: "server"} }
+
+        it "includes server" do
+          expect(subject.to_h).to include({server: "server"})
+        end
+      end
+
+      context "when connection_options is set" do
+        let(:options) { {username: "user", password: "pwd", connection_options: "foo"} }
+
+        it "includes connection_options" do
+          expect(subject.to_h).to include({connection_options: "foo"})
+        end
+      end
+    end
+
+    describe "#multi_fetch_size" do
+      let(:options) { {username: "user", password: "pwd", multi_fetch_size: multi_fetch_size} }
+      let(:multi_fetch_size) { 10 }
+
+      it "returns the initialized value" do
+        expect(subject.multi_fetch_size).to eq(10)
+      end
+
+      context "when the initialized value is a string representation of a positive number" do
+        let(:multi_fetch_size) { "10" }
+
+        it "returns one" do
+          expect(subject.multi_fetch_size).to eq(10)
+        end
+      end
+
+      context "when the initialized value is not a number" do
+        let(:multi_fetch_size) { "ciao" }
+
+        it "returns one" do
+          expect(subject.multi_fetch_size).to eq(1)
+        end
+      end
+
+      context "when the initialized value is not a positive number" do
+        let(:multi_fetch_size) { "-99" }
+
+        it "returns one" do
+          expect(subject.multi_fetch_size).to eq(1)
+        end
+      end
+    end
+
+    [
+      [:username, "username", "username"],
+      [:password, "password", "password"],
+      [:local_path, "local_path", "local_path"],
+      [:multi_fetch_size, "2", 2],
+      [:server, "server", "server"],
+      [:folders, ["folder"], ["folder"]],
+      [:connection_options, '{"some": "option"}', {"some" => "option"}]
+    ].each do |attribute, value, expected|
+      describe "##{attribute}=" do
+        let(:options) { {} }
+
+        before { subject.send(:"#{attribute}=", value) }
+
+        it "sets the #{attribute}" do
+          expect(subject.send(attribute)).to eq(expected)
+        end
+
+        it "adds a change" do
+          expect(subject.changes).to eq(attribute => {from: nil, to: expected})
+        end
+
+        if attribute == :folders
+          context "when the supplied value is not an Array" do
+            it "fails" do
+              expect do
+                subject.folders = "aaa"
+              end.to raise_error(RuntimeError, /must be an Array/)
+            end
+          end
+        end
+
+        if attribute == :multi_fetch_size
+          context "when the supplied value is not a number" do
+            before { subject.multi_fetch_size = "ciao" }
+
+            it "sets multi_fetch_size to one" do
+              expect(subject.multi_fetch_size).to eq(1)
+            end
+          end
+
+          context "when the supplied value is not a positive number" do
+            before { subject.multi_fetch_size = "-1" }
+
+            it "sets multi_fetch_size to one" do
+              expect(subject.multi_fetch_size).to eq(1)
+            end
+          end
+        end
+
+        if attribute == :connection_options
+          context "when the supplied value is not valid JSON" do
+            it "fails" do
+              expect do
+                subject.connection_options = "NOT JSON"
+              end.to raise_error(JSON::ParserError)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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