imap-backup 5.2.0 → 6.0.1

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

@@ -1,137 +0,0 @@
-module Imap::Backup
-  describe Setup::Asker do
-    subject { described_class.new(highline) }
-
-    let(:highline) { double }
-    let(:query) do
-      instance_double(
-        HighLine::Question,
-        "default=": nil,
-        "readline=": nil,
-        "validate=": nil,
-        "responses": {},
-        "echo=": nil
-      )
-    end
-    let(:answer) { "foo" }
-
-    before do
-      allow(Setup).to receive(:highline) { highline }
-      allow(highline).to receive(:ask) do |&b|
-        b.call query
-        answer
-      end
-    end
-
-    [
-      [:email, [], "email address"],
-      [:password, [], "password"],
-      [:backup_path, %w(x y), "backup directory"]
-    ].each do |method, params, prompt|
-      context ".#{method}" do
-        it "asks for input" do
-          expect(highline).to receive(:ask).with("#{prompt}: ")
-
-          described_class.send(method, *params)
-        end
-
-        it "returns the answer" do
-          expect(described_class.send(method, *params)).to eq(answer)
-        end
-      end
-    end
-
-    describe "#initialize" do
-      it "requires 1 parameter" do
-        expect do
-          described_class.new
-        end.to raise_error(ArgumentError, /wrong number/)
-      end
-
-      it "expects a higline" do
-        expect(subject.highline).to eq(highline)
-      end
-    end
-
-    describe "#email" do
-      let(:email) { "email@example.com" }
-      let(:answer) { email }
-
-      it "asks for an email" do
-        expect(highline).to receive(:ask).with(/email/)
-
-        subject.email
-      end
-
-      it "returns the address" do
-        expect(subject.email).to eq(email)
-      end
-    end
-
-    describe "#password" do
-      let(:password1) { "password" }
-      let(:password2) { "password" }
-      let(:answers) { [true, false] }
-
-      before do
-        i = 0
-        allow(highline).to receive(:ask).with("password: ") { password1 }
-        allow(highline).to receive(:ask).with("repeat password: ") { password2 }
-        allow(highline).to receive(:agree) do
-          answer = answers[i]
-          i += 1
-          answer
-        end
-      end
-
-      it "asks for a password" do
-        expect(highline).to receive(:ask).with("password: ")
-
-        subject.password
-      end
-
-      it "asks for confirmation" do
-        expect(highline).to receive(:ask).with("repeat password: ")
-
-        subject.password
-      end
-
-      it "returns the password" do
-        expect(subject.password).to eq(password1)
-      end
-
-      context "with different answers" do
-        let(:password2) { "secret" }
-
-        it "asks to continue" do
-          expect(highline).to receive(:agree).
-            at_least(:once).with(/Continue\?/)
-
-          subject.password
-        end
-      end
-    end
-
-    describe "#backup_path" do
-      let(:path) { "/path" }
-      let(:answer) { path }
-
-      before do
-        allow(highline).to receive(:ask) do |&b|
-          b.call query
-          path
-        end
-      end
-
-      it "asks for a directory" do
-        expect(highline).to receive(:ask).with(/directory/)
-
-        subject.backup_path("", //)
-      end
-
-      it "returns the path" do
-        expect(subject.backup_path("", //)).to eq(path)
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-describe Imap::Backup::Setup::ConnectionTester do
-  describe "#test" do
-    subject { described_class.new("foo") }
-
-    let(:connection) do
-      instance_double(Imap::Backup::Account::Connection, client: nil)
-    end
-
-    before do
-      allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
-    end
-
-    it "tries to connect" do
-      expect(connection).to receive(:client)
-
-      subject.test
-    end
-
-    describe "success" do
-      it "returns success" do
-        expect(subject.test).to match(/successful/)
-      end
-    end
-
-    describe "failure" do
-      before do
-        allow(connection).to receive(:client).and_raise(error)
-      end
-
-      context "with no connection" do
-        let(:error) do
-          data = OpenStruct.new(text: "bar")
-          response = OpenStruct.new(data: data)
-          Net::IMAP::NoResponseError.new(response)
-        end
-
-        it "returns error" do
-          expect(subject.test).to match(/no response/i)
-        end
-      end
-
-      context "when caused by other errors" do
-        let(:error) { "Error" }
-
-        it "returns error" do
-          expect(subject.test).to match(/unexpected error/i)
-        end
-      end
-    end
-  end
-end

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_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/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::Mbox,
-      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