imap-backup 6.0.0.rc2 → 6.0.0

data/spec/unit/imap/backup/account/folder_spec.rb

@@ -1,261 +0,0 @@
-# rubocop:disable RSpec/PredicateMatcher
-
-describe Imap::Backup::Account::Folder do
-  FOLDER_NAME = "Gelöscht".freeze
-  ENCODED_FOLDER_NAME = "Gel&APY-scht".freeze
-
-  subject { described_class.new(connection, FOLDER_NAME) }
-
-  let(:client) do
-    instance_double(
-      Imap::Backup::Client::Default,
-      append: append_response,
-      create: nil,
-      examine: nil,
-      expunge: nil,
-      responses: responses,
-      select: nil,
-      uid_store: nil
-    )
-  end
-  let(:connection) do
-    instance_double(Imap::Backup::Account::Connection, client: client)
-  end
-  let(:missing_mailbox_data) do
-    OpenStruct.new(text: "Unknown Mailbox: #{FOLDER_NAME}")
-  end
-  let(:missing_mailbox_response) { OpenStruct.new(data: missing_mailbox_data) }
-  let(:missing_mailbox_error) do
-    Net::IMAP::NoResponseError.new(missing_mailbox_response)
-  end
-  let(:responses) { [] }
-  let(:append_response) { nil }
-  let(:uids) { [5678, 123] }
-
-  before { allow(client).to receive(:uid_search) { uids } }
-
-  describe "#uids" do
-    it "lists available messages" do
-      expect(subject.uids).to eq(uids.reverse)
-    end
-
-    context "with missing mailboxes" do
-      before do
-        allow(client).to receive(:examine).
-          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
-      end
-
-      it "returns an empty array" do
-        expect(subject.uids).to eq([])
-      end
-    end
-
-    context "with no SEARCH response in Net::IMAP" do
-      let(:no_method_error) do
-        NoMethodError.new("Somethimes SEARCH responses come out undefined")
-      end
-
-      before do
-        allow(client).to receive(:examine).
-          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
-      end
-
-      it "returns an empty array" do
-        expect(subject.uids).to eq([])
-      end
-    end
-
-    context "when the UID search fails" do
-      before do
-        allow(client).to receive(:uid_search).and_raise(NoMethodError)
-      end
-
-      it "returns an empty array" do
-        expect(subject.uids).to eq([])
-      end
-    end
-  end
-
-  describe "#fetch_multi" do
-    let(:message_body) { instance_double(String, force_encoding: nil) }
-    let(:attributes) { {"UID" => "uid", "BODY[]" => message_body, "other" => "xxx"} }
-    let(:fetch_data_item) do
-      instance_double(Net::IMAP::FetchData, attr: attributes)
-    end
-
-    before { allow(client).to receive(:uid_fetch) { [fetch_data_item] } }
-
-    it "returns the uid and message" do
-      expect(subject.fetch_multi([123])).to eq([{uid: "uid", body: message_body}])
-    end
-
-    context "when the server responds with nothing" do
-      before { allow(client).to receive(:uid_fetch) { nil } }
-
-      it "is nil" do
-        expect(subject.fetch_multi([123])).to be_nil
-      end
-    end
-
-    context "when the mailbox doesn't exist" do
-      before do
-        allow(client).to receive(:examine).
-          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
-      end
-
-      it "is nil" do
-        expect(subject.fetch_multi([123])).to be_nil
-      end
-    end
-
-    context "when the first fetch_uid attempts fail" do
-      before do
-        outcomes = [-> { raise EOFError }, -> { [fetch_data_item] }]
-        allow(client).to receive(:uid_fetch) { outcomes.shift.call }
-      end
-
-      it "retries" do
-        subject.fetch_multi([123])
-
-        expect(client).to have_received(:uid_fetch).twice
-      end
-
-      it "succeeds" do
-        subject.fetch_multi([123])
-      end
-    end
-  end
-
-  describe "#folder" do
-    it "is the name" do
-      expect(subject.folder).to eq(FOLDER_NAME)
-    end
-  end
-
-  describe "#exist?" do
-    context "when the folder exists" do
-      it "is true" do
-        expect(subject.exist?).to be_truthy
-      end
-    end
-
-    context "when the folder doesn't exist" do
-      before do
-        allow(client).to receive(:examine).
-          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
-      end
-
-      it "is false" do
-        expect(subject.exist?).to be_falsey
-      end
-    end
-  end
-
-  describe "#create" do
-    context "when the folder exists" do
-      it "is does not create the folder" do
-        expect(client).to_not receive(:create)
-
-        subject.create
-      end
-    end
-
-    context "when the folder doesn't exist" do
-      before do
-        allow(client).to receive(:examine).
-          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
-      end
-
-      it "creates the folder" do
-        expect(client).to receive(:create)
-
-        subject.create
-      end
-
-      it "encodes the folder name" do
-        expect(client).to receive(:create).with(ENCODED_FOLDER_NAME)
-
-        subject.create
-      end
-    end
-  end
-
-  describe "#uid_validity" do
-    let(:responses) { {"UIDVALIDITY" => ["x", "uid validity"]} }
-
-    it "is returned" do
-      expect(subject.uid_validity).to eq("uid validity")
-    end
-
-    context "when the folder doesn't exist" do
-      before do
-        allow(client).to receive(:examine).
-          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
-      end
-
-      it "raises an error" do
-        expect do
-          subject.uid_validity
-        end.to raise_error(Imap::Backup::FolderNotFound)
-      end
-    end
-  end
-
-  describe "#append" do
-    let(:message) do
-      instance_double(
-        Email::Mboxrd::Message,
-        imap_body: "imap body",
-        date: message_date
-      )
-    end
-    let(:message_date) { Time.new(2010, 10, 10, 9, 15, 22, 0) }
-    let(:append_response) do
-      OpenStruct.new(data: OpenStruct.new(code: OpenStruct.new(data: "1 2")))
-    end
-
-    it "appends the message" do
-      expect(client).to receive(:append)
-
-      subject.append(message)
-    end
-
-    it "sets the date and time" do
-      expect(client).to receive(:append).
-        with(anything, anything, anything, message_date)
-
-      subject.append(message)
-    end
-
-    it "returns the new uid" do
-      expect(subject.append(message)).to eq(2)
-    end
-
-    it "set the new uid validity" do
-      subject.append(message)
-
-      expect(subject.uid_validity).to eq(1)
-    end
-  end
-
-  describe "#clear" do
-    before do
-      subject.clear
-    end
-
-    it "uses select to have read-write access" do
-      expect(client).to have_received(:select)
-    end
-
-    it "marks all emails as deleted" do
-      expect(client).
-        to have_received(:uid_store).with(uids.sort, "+FLAGS", [:Deleted])
-    end
-
-    it "deletes marked emails" do
-      expect(client).to have_received(:expunge)
-    end
-  end
-end
-
-# rubocop:enable RSpec/PredicateMatcher

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

@@ -1,246 +0,0 @@
-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,58 +0,0 @@
-require "imap/backup/cli/accounts"
-
-describe Imap::Backup::CLI::Accounts do
-  subject { described_class.new(required_accounts) }
-
-  let(:required_accounts) { [] }
-  let(:accounts) { [account1, account2] }
-  let(:account1) do
-    instance_double(
-      Imap::Backup::Account,
-      username: "a1@example.com"
-    )
-  end
-  let(:account2) do
-    instance_double(
-      Imap::Backup::Account,
-      username: "a2@example.com"
-    )
-  end
-  let(:store) do
-    instance_double(Imap::Backup::Configuration, accounts: accounts)
-  end
-  let(:exists) { true }
-
-  before do
-    allow(Imap::Backup::Configuration).to receive(:new) { store }
-    allow(Imap::Backup::Configuration).
-      to receive(:exist?) { exists }
-  end
-
-  describe "#each" do
-    specify "calls the block with each account" do
-      result = subject.map { |a| a }
-
-      expect(result).to eq(accounts)
-    end
-
-    context "when the configuration file is missing" do
-      let(:exists) { false }
-
-      it "fails" do
-        expect do
-          subject.each {}
-        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

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

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

@@ -1,87 +0,0 @@
-require "imap/backup/cli/helpers"
-
-module Imap::Backup
-  class WithHelpers
-    include CLI::Helpers
-  end
-
-  RSpec.describe CLI::Helpers do
-    subject { WithHelpers.new }
-
-    let(:accounts) { instance_double(CLI::Accounts) }
-    let(:email) { "email@example.com" }
-    let(:account1) { instance_double(Account, username: email, connection: "c1") }
-    let(:account2) { instance_double(Account, username: "foo", connection: "c2") }
-    let(:items) { [account1, account2] }
-
-    before do
-      allow(CLI::Accounts).to receive(:new) { accounts }
-      allow(accounts).to receive(:each).
-        and_yield(account1).
-        and_yield(account2)
-      allow(accounts).to receive(:find) do |&block|
-        items.find { |a| block.call(a) }
-      end
-    end
-
-    describe ".symbolized" do
-      let(:arguments) { {"foo" => 1, "bar" => 2} }
-      let(:result) { subject.symbolized(arguments) }
-
-      it "converts string keys to symbols" do
-        expect(result.keys).to eq([:foo, :bar])
-      end
-
-      context "when keys have hyphens" do
-        let(:arguments) { {"some-option"=> 3} }
-
-        it "replaces them with underscores" do
-          expect(result.keys).to eq([:some_option])
-        end
-      end
-    end
-
-    describe ".account" do
-      it "returns any account with a matching username" do
-        expect(subject.account(email)).to eq(account1)
-      end
-
-      context "when no match is found" do
-        let(:items) { [account2] }
-        it "fails" do
-          expect do
-            subject.account(email)
-          end.to raise_error(RuntimeError, /not a configured account/)
-        end
-      end
-    end
-
-    describe ".connection" do
-      it "returns the connection for any account with a matching username" do
-        result = subject.connection(email)
-        expect(result).to be_a(Account::Connection)
-        expect(result.account).to eq(account1)
-      end
-    end
-
-    describe ".each_connection" do
-      it "yields each connection" do
-        expect { |b| subject.each_connection([email, "foo"], &b) }.
-          to yield_successive_args("c1", "c2")
-      end
-
-      context "when there is no configuration" do
-        before do
-          allow(accounts).to receive(:each).
-            and_raise(Imap::Backup::ConfigurationNotFound)
-        end
-
-        it "fails" do
-          expect do
-            subject.each_connection([email])
-          end.to raise_error(RuntimeError, /not configured/)
-        end
-      end
-    end
-  end
-end