imap-backup 6.0.0.rc2 → 6.0.0

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

@@ -1,146 +0,0 @@
-describe Imap::Backup::Setup::FolderChooser do
-  include HighLineTestHelpers
-
-  describe "#run" do
-    subject { described_class.new(account) }
-
-    let(:connection) do
-      instance_double(
-        Imap::Backup::Account::Connection, folder_names: connection_folders
-      )
-    end
-    let(:account) do
-      instance_double(
-        Imap::Backup::Account,
-        folders: account_folders,
-        "folders=": nil
-      )
-    end
-    let(:account_folders) { [] }
-    let(:connection_folders) { [] }
-    let!(:highline_streams) { prepare_highline }
-    let(:input) { highline_streams[0] }
-    let(:output) { highline_streams[1] }
-
-    before do
-      allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
-      allow(Kernel).to receive(:system)
-      allow(Imap::Backup::Logger.logger).to receive(:warn)
-    end
-
-    describe "display" do
-      it "clears the screen" do
-        expect(Kernel).to receive(:system).with("clear")
-
-        subject.run
-      end
-
-      it "shows the menu" do
-        subject.run
-
-        expect(output.string).to match %r{Add/remove folders}
-      end
-    end
-
-    describe "folder listing" do
-      let(:account_folders) { [{name: "my_folder"}]}
-      let(:connection_folders) do
-        # N.B. my_folder is already backed up
-        %w(my_folder another_folder)
-      end
-
-      describe "display" do
-        before { subject.run }
-
-        it "shows folders which are being backed up" do
-          expect(output.string).to include("+ my_folder")
-        end
-
-        it "shows folders which are not being backed up" do
-          expect(output.string).to include("- another_folder")
-        end
-      end
-
-      context "when adding folders" do
-        before do
-          allow(input).to receive(:gets).and_return("2\n", "q\n")
-
-          subject.run
-        end
-
-        specify "are added to the account" do
-          expect(account).to have_received(:"folders=").
-            with([{name: "my_folder"}, {name: "another_folder"}])
-        end
-      end
-
-      context "when removing folders" do
-        before do
-          allow(input).to receive(:gets).and_return("1\n", "q\n")
-
-          subject.run
-        end
-
-        specify "are removed from the account" do
-          expect(account).to have_received(:"folders=").with([])
-        end
-      end
-    end
-
-    context "with missing remote folders" do
-      let(:account_folders) do
-        [{name: "on_server"}, {name: "not_on_server"}]
-      end
-      let(:connection_folders) { ["on_server"] }
-
-      before do
-        allow(Kernel).to receive(:puts)
-        subject.run
-      end
-
-      specify "are removed from the account" do
-        expect(account).to have_received(:"folders=").
-          with([{name: "on_server"}])
-      end
-    end
-
-    context "when folders are not available" do
-      let(:connection_folders) { nil }
-
-      before do
-        allow(Imap::Backup::Setup.highline).
-          to receive(:ask) { "q" }
-      end
-
-      it "asks to press a key" do
-        expect(Imap::Backup::Setup.highline).
-          to receive(:ask).with("Press a key ")
-
-        subject.run
-      end
-    end
-
-    context "with connection errors" do
-      before do
-        allow(Imap::Backup::Account::Connection).
-          to receive(:new).with(account).and_raise("error")
-        allow(Imap::Backup::Setup.highline).
-          to receive(:ask) { "q" }
-      end
-
-      it "prints an error message" do
-        expect(Imap::Backup::Logger.logger).
-          to receive(:warn).with("Connection failed")
-
-        subject.run
-      end
-
-      it "asks to continue" do
-        expect(Imap::Backup::Setup.highline).
-          to receive(:ask).with("Press a key ")
-
-        subject.run
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-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/setup_spec.rb

@@ -1,301 +0,0 @@
-describe Imap::Backup::Setup do
-  include HighLineTestHelpers
-
-  subject { described_class.new }
-
-  let(:normal_account) do
-    instance_double(
-      Imap::Backup::Account,
-      username: "account@example.com",
-      marked_for_deletion?: false,
-      modified?: false
-    )
-  end
-  let(:modified_account) do
-    instance_double(
-      Imap::Backup::Account,
-      username: "modified@example.com",
-      marked_for_deletion?: false,
-      modified?: true
-    )
-  end
-  let(:deleted_account) do
-    instance_double(
-      Imap::Backup::Account,
-      username: "delete@example.com",
-      marked_for_deletion?: true,
-      modified?: false
-    )
-  end
-  let(:accounts) { [normal_account] }
-  let(:store) do
-    instance_double(
-      Imap::Backup::Configuration,
-      "accounts": accounts,
-      "path": "/base/path",
-      "save": nil,
-      "debug?": debug,
-      "debug=": nil,
-      "modified?": config_modified
-    )
-  end
-  let(:debug) { false }
-  let(:config_modified) { false }
-  let!(:highline_streams) { prepare_highline }
-  let(:input) { highline_streams[0] }
-  let(:output) { highline_streams[1] }
-  let(:gmail_imap_server) { "imap.gmail.com" }
-
-  describe "#initialize" do
-    context "without a config file" do
-      it "works" do
-        described_class.new
-      end
-    end
-  end
-
-  describe "#run" do
-    before do
-      allow(Imap::Backup::Configuration).to receive(:new) { store }
-      allow(Imap::Backup::Logger).to receive(:setup_logging)
-      allow(input).to receive(:eof?) { false }
-      allow(input).to receive(:gets) { "q\n" }
-      allow(Kernel).to receive(:system)
-    end
-
-    describe "main menu" do
-      context "when changes have not been made" do
-        before { subject.run }
-
-        ["add account", "quit"].each do |choice|
-          it "includes #{choice}" do
-            expect(output.string).to include(choice)
-          end
-        end
-      end
-
-      context "when changes have been made" do
-        let(:config_modified) { true }
-
-        before do
-          allow(input).to receive(:gets) { "exit\n" }
-          subject.run
-        end
-
-        ["save and exit", "exit without saving"].each do |choice|
-          it "includes '#{choice}'" do
-            expect(output.string).to include(choice)
-          end
-        end
-      end
-    end
-
-    it "clears the screen" do
-      expect(Kernel).to receive(:system).with("clear")
-
-      subject.run
-    end
-
-    describe "listing" do
-      let(:accounts) { [normal_account, modified_account, deleted_account] }
-
-      before { subject.run }
-
-      describe "normal accounts" do
-        it "are listed" do
-          expect(output.string).to match(/account@example.com/)
-        end
-      end
-
-      describe "modified accounts" do
-        it "are flagged" do
-          expect(output.string).to match(/modified@example.com \*/)
-        end
-      end
-
-      describe "deleted accounts" do
-        it "are hidden" do
-          expect(output.string).to_not match(/delete@example.com/)
-        end
-      end
-    end
-
-    context "when editing accounts" do
-      let(:account) do
-        instance_double(Imap::Backup::Setup::Account, run: nil)
-      end
-      let(:config_modified) { true }
-
-      before do
-        allow(input).to receive(:gets).and_return("1\n", "exit\n")
-        allow(Imap::Backup::Setup::Asker).to receive(:email).
-          with(no_args) { "new@example.com" }
-        allow(Imap::Backup::Setup::Account).to receive(:new).
-          with(store, normal_account, anything) { account }
-      end
-
-      it "edits the account" do
-        expect(account).to receive(:run)
-
-        subject.run
-      end
-    end
-
-    context "when adding accounts" do
-      let(:blank_account) do
-        {
-          username: added_email,
-          password: "",
-          local_path: local_path,
-          folders: []
-        }
-      end
-      let(:account) do
-        instance_double(Imap::Backup::Setup::Account, run: nil)
-      end
-      let(:config_modified) { true }
-      let(:added_email) { "new@example.com" }
-      let(:local_path) { "/base/path/new_example.com" }
-
-      before do
-        allow(input).to receive(:gets).and_return("add\n", "exit\n")
-        allow(Imap::Backup::Setup::Asker).to receive(:email).
-          with(no_args) { added_email }
-        allow(Imap::Backup::Setup::Account).to receive(:new).
-          with(store, anything, anything) { account }
-
-        subject.run
-      end
-
-      it "sets username" do
-        expect(accounts[1].username).to eq(added_email)
-      end
-
-      it "sets blank password" do
-        expect(accounts[1].password).to eq("")
-      end
-
-      it "sets local_path" do
-        expect(accounts[1].local_path).to eq(local_path)
-      end
-
-      it "sets folders" do
-        expect(accounts[1].folders).to eq([])
-      end
-
-      context "when the account is a GMail account" do
-        let(:added_email) { "new@gmail.com" }
-        let(:local_path) { "/base/path/new_gmail.com" }
-
-        it "sets the server" do
-          expect(accounts[1].server).to eq(gmail_imap_server)
-        end
-      end
-
-      it "doesn't flag the unedited account as modified" do
-        expect(accounts[1].modified?).to be_falsey
-      end
-    end
-
-    describe "logging" do
-      context "when debug logging is disabled" do
-        let(:config_modified) { true }
-
-        before do
-          allow(input).to receive(:gets).and_return("start\n", "exit\n")
-        end
-
-        it "shows a menu item" do
-          subject.run
-
-          expect(output.string).to include("start logging")
-        end
-
-        context "when selected" do
-          it "sets the debug flag" do
-            expect(store).to receive(:debug=).with(true)
-
-            subject.run
-          end
-
-          it "updates logging status" do
-            expect(Imap::Backup::Logger).to receive(:setup_logging)
-
-            subject.run
-          end
-        end
-      end
-
-      context "when debug logging is enabled" do
-        let(:debug) { true }
-        let(:config_modified) { true }
-
-        before do
-          allow(input).to receive(:gets).and_return("stop\n", "exit\n")
-        end
-
-        it "shows a menu item" do
-          subject.run
-
-          expect(output.string).to include("stop logging")
-        end
-
-        context "when selected" do
-          before do
-            allow(input).to receive(:gets).and_return("stop\n", "exit\n")
-          end
-
-          it "unsets the debug flag" do
-            expect(store).to receive(:debug=).with(false)
-
-            subject.run
-          end
-
-          it "updates logging status" do
-            expect(Imap::Backup::Logger).to receive(:setup_logging)
-
-            subject.run
-          end
-        end
-      end
-    end
-
-    context "when 'save' is selected" do
-      let(:config_modified) { true }
-
-      before do
-        allow(input).to receive(:gets) { "save\n" }
-      end
-
-      it "exits" do
-        # N.B. this will hang forever if save does not cause an exit
-        subject.run
-      end
-
-      it "saves the configuration" do
-        expect(store).to receive(:save)
-
-        subject.run
-      end
-    end
-
-    context "when 'exit without saving' is selected" do
-      let(:config_modified) { true }
-
-      before do
-        allow(input).to receive(:gets) { "exit\n" }
-      end
-
-      it "exits" do
-        # N.B. this will hang forever if quit does not cause an exit
-        subject.run
-      end
-
-      it "doesn't save the configuration" do
-        expect(store).to_not receive(:save)
-
-        subject.run
-      end
-    end
-  end
-end

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

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

@@ -1,54 +0,0 @@
-describe Imap::Backup::Uploader do
-  subject { described_class.new(folder, serializer) }
-
-  let(:folder) do
-    instance_double(
-      Imap::Backup::Account::Folder, uids: [2, 3], append: 99, name: "foo"
-    )
-  end
-  let(:serializer) do
-    instance_double(
-      Imap::Backup::Serializer,
-      uids: [1, 2],
-      update_uid: nil
-    )
-  end
-  let(:missing_message) do
-    instance_double(Email::Mboxrd::Message, supplied_body: "missing message")
-  end
-  let(:existing_message) do
-    instance_double(Email::Mboxrd::Message, supplied_body: "existing message")
-  end
-
-  def message_enumerator
-    yield [1, missing_message]
-  end
-
-  describe "#run" do
-    before do
-      allow(serializer).to receive(:each_message).and_return(enum_for(:message_enumerator))
-    end
-
-    context "with messages that are missing" do
-      it "restores them" do
-        expect(folder).to receive(:append).with(missing_message)
-
-        subject.run
-      end
-
-      it "updates the local message id" do
-        expect(serializer).to receive(:update_uid).with(1, 99)
-
-        subject.run
-      end
-    end
-
-    context "with messages that are present on server" do
-      it "does nothing" do
-        expect(folder).to_not receive(:append).with(existing_message)
-
-        subject.run
-      end
-    end
-  end
-end