imap-backup 6.0.0.rc2 → 6.0.0

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

@@ -1,100 +0,0 @@
-describe Imap::Backup::CLI::Local do
-  let(:accounts) do
-    instance_double(
-      Imap::Backup::CLI::Accounts,
-      find: ->(&block) { [account].find { |a| block.call(a) } }
-    )
-  end
-  let(:account) do
-    instance_double(
-      Imap::Backup::Account,
-      username: email,
-      marked_for_deletion?: false,
-      modified?: false
-    )
-  end
-  let(:connection) do
-    instance_double(
-      Imap::Backup::Account::Connection,
-      local_folders: local_folders
-    )
-  end
-  let(:local_folders) { [[serializer, folder]] }
-  let(:folder) { instance_double(Imap::Backup::Account::Folder, name: "bar") }
-  let(:serializer) do
-    instance_double(
-      Imap::Backup::Serializer,
-      uids: uids,
-      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: message_subject,
-      supplied_body: "Supplied"
-    )
-  end
-  let(:message_subject) { "Ciao" }
-  let(:email) { "foo@example.com" }
-
-  before do
-    allow(Kernel).to receive(:puts)
-    allow(Imap::Backup::CLI::Accounts).to receive(:new) { accounts }
-    allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
-    allow(Mail).to receive(:new) { mail }
-    allow(accounts).to receive(:each).and_yield(account)
-  end
-
-  describe "accounts" do
-    it "lists configured emails" do
-      subject.accounts
-
-      expect(Kernel).to have_received(:puts).with(email)
-    end
-  end
-
-  describe "folders" do
-    it "lists downloaded folders in quotes" do
-      subject.folders(email)
-
-      expect(Kernel).to have_received(:puts).with(%("bar"))
-    end
-  end
-
-  describe "list" do
-    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
-    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

@@ -1,80 +0,0 @@
-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

@@ -1,67 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-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

@@ -1,125 +0,0 @@
-module Imap::Backup
-  describe CLI::Utils do
-    let(:accounts) do
-      instance_double(
-        CLI::Accounts,
-        find: ->(&block) { [account].find { |a| block.call(a) } }
-      )
-    end
-    let(:account) { instance_double(Account, username: email) }
-    let(:connection) do
-      instance_double(
-        Account::Connection,
-        account: account,
-        backup_folders: [folder],
-        local_folders: ["folder"]
-      )
-    end
-    let(:account) do
-      instance_double(
-        Account,
-        local_path: "path"
-      )
-    end
-    let(:folder) do
-      instance_double(
-        Account::Folder,
-        exist?: true,
-        name: "name",
-        uid_validity: "uid_validity",
-        uids: %w(123 456)
-      )
-    end
-    let(:serializer) do
-      instance_double(
-        Serializer,
-        uids: %w(123 789),
-        apply_uid_validity: 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).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
-      it "ensures the local UID validity matches the server" do
-        subject.ignore_history(email)
-
-        expect(serializer).to have_received(:apply_uid_validity).with("uid_validity")
-      end
-
-      it "fills the local folder with fake emails" do
-        subject.ignore_history(email)
-
-        expect(serializer).to have_received(:append).with("456", /From: fake@email.com/)
-      end
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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/client/default_spec.rb

@@ -1,22 +0,0 @@
-describe Imap::Backup::Client::Default do
-  subject { described_class.new("server", {}) }
-
-  let(:imap) { instance_double(Net::IMAP, list: imap_folders) }
-  let(:imap_folders) { [] }
-
-  before do
-    allow(Net::IMAP).to receive(:new) { imap }
-  end
-
-  describe "#list" do
-    context "with non-ASCII folder names" do
-      let(:imap_folders) do
-        [instance_double(Net::IMAP::MailboxList, name: "Gel&APY-scht")]
-      end
-
-      it "converts them to UTF-8" do
-        expect(subject.list).to eq(["Gelöscht"])
-      end
-    end
-  end
-end