imap-backup 5.2.0 → 6.0.1

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

@@ -1,251 +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
-  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/cli/accounts_spec.rb

@@ -1,47 +0,0 @@
-require "imap/backup/cli/accounts"
-
-describe Imap::Backup::CLI::Accounts do
-  subject { described_class.new }
-
-  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
-  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

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

@@ -1,81 +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::Mbox,
-      uids: uids,
-      each_message: [[123, message]]
-    )
-  end
-  let(:uids) { ["123"] }
-  let(:message) do
-    instance_double(
-      Email::Mboxrd::Message,
-      date: Date.today,
-      subject: "Ciao",
-      supplied_body: "Supplied"
-    )
-  end
-  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
-    it "lists downloaded emails" do
-      subject.list(email, "bar")
-
-      expect(Kernel).to have_received(:puts).with(/Ciao/)
-    end
-  end
-
-  describe "show" do
-    it "prints a downloaded email" do
-      subject.show(email, "bar", "123")
-
-      expect(Kernel).to have_received(:puts).with("Supplied")
-    end
-  end
-end

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

@@ -1,62 +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]
-      )
-    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::Mbox,
-        uids: %w(123 789),
-        apply_uid_validity: nil,
-        save: nil
-      )
-    end
-    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 }
-    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(:save).with("456", /From: fake@email.com/)
-      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