imap-backup 5.2.0 → 6.0.1

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

@@ -1,238 +0,0 @@
-require "json"
-require "os"
-
-# rubocop:disable RSpec/PredicateMatcher
-
-describe Imap::Backup::Configuration do
-  let(:directory) { "/base/path" }
-  let(:file_path) { File.join(directory, "/config.json") }
-  let(:file_exists) { true }
-  let(:directory_exists) { true }
-  let(:debug) { true }
-  let(:configuration) { data.to_json }
-  let(:data) { {debug: debug, accounts: accounts.map(&:to_h)} }
-  let(:accounts) { [account1, account2] }
-  let(:account1) { Imap::Backup::Account.new({username: "username1"}) }
-  let(:account2) { Imap::Backup::Account.new({username: "username2"}) }
-
-  before do
-    stub_const(
-      "Imap::Backup::Configuration::CONFIGURATION_DIRECTORY", directory
-    )
-    allow(File).to receive(:directory?).with(directory) { directory_exists }
-    allow(File).to receive(:exist?).and_call_original
-    allow(File).to receive(:exist?).with(file_path) { file_exists }
-    allow(Imap::Backup::Utils).
-      to receive(:stat).with(directory) { 0o700 }
-    allow(Imap::Backup::Utils).
-      to receive(:stat).with(file_path) { 0o600 }
-    allow(Imap::Backup::Utils).to receive(:check_permissions) { nil }
-    allow(File).to receive(:read).with(file_path) { configuration }
-  end
-
-  describe ".exist?" do
-    [true, false].each do |exists|
-      state = exists ? "exists" : "doesn't exist"
-      context "when the file #{state}" do
-        let(:file_exists) { exists }
-
-        it "returns #{exists}" do
-          expect(described_class.exist?).to eq(file_exists)
-        end
-      end
-    end
-  end
-
-  describe "#path" do
-    it "is the directory containing the configuration file" do
-      expect(subject.path).to eq(directory)
-    end
-  end
-
-  describe "#modified?" do
-    context "with modified accounts" do
-      before { subject.accounts[0].username = "changed" }
-
-      it "is true" do
-        expect(subject.modified?).to be_truthy
-      end
-    end
-
-    context "with accounts flagged 'delete'" do
-      before { subject.accounts[0].mark_for_deletion! }
-
-      it "is true" do
-        expect(subject.modified?).to be_truthy
-      end
-    end
-
-    context "without accounts flagged 'modified'" do
-      it "is false" do
-        expect(subject.modified?).to be_falsey
-      end
-    end
-  end
-
-  describe "#debug?" do
-    context "when the debug flag is true" do
-      it "is true" do
-        expect(subject.debug?).to be_truthy
-      end
-    end
-
-    context "when the debug flag is false" do
-      let(:debug) { false }
-
-      it "is false" do
-        expect(subject.debug?).to be_falsey
-      end
-    end
-
-    context "when the debug flag is missing" do
-      let(:data) { {accounts: accounts} }
-
-      it "is false" do
-        expect(subject.debug?).to be_falsey
-      end
-    end
-
-    context "when the debug flag is neither true nor false" do
-      let(:debug) { "hi" }
-
-      it "is false" do
-        expect(subject.debug?).to be_falsey
-      end
-    end
-  end
-
-  describe "#debug=" do
-    before { subject.debug = debug }
-
-    context "when the supplied value is true" do
-      it "sets the flag to true" do
-        expect(subject.debug?).to be_truthy
-      end
-    end
-
-    context "when the supplied value is false" do
-      let(:debug) { false }
-
-      it "sets the flag to false" do
-        expect(subject.debug?).to be_falsey
-      end
-    end
-
-    context "when the supplied value is neither true nor false" do
-      let(:debug) { "ciao" }
-
-      it "sets the flag to false" do
-        expect(subject.debug?).to be_falsey
-      end
-    end
-  end
-
-  describe "#save" do
-    subject { described_class.new }
-
-    let(:directory_exists) { false }
-    let(:file) { instance_double(File, write: nil) }
-
-    before do
-      allow(FileUtils).to receive(:mkdir)
-      allow(FileUtils).to receive(:chmod)
-      allow(File).to receive(:open).with(file_path, "w").and_yield(file)
-      allow(JSON).to receive(:pretty_generate) { "JSON output" }
-    end
-
-    it "creates the config directory" do
-      expect(FileUtils).to receive(:mkdir).with(directory)
-
-      subject.save
-    end
-
-    it "saves the configuration" do
-      expect(file).to receive(:write).with("JSON output")
-
-      subject.save
-    end
-
-    it "uses the Account#to_h method" do
-      allow(subject.accounts[0]).to receive(:to_h) { "Account1" }
-      allow(subject.accounts[1]).to receive(:to_h) { "Account2" }
-
-      expect(JSON).to receive(:pretty_generate).
-        with(hash_including({accounts: ["Account1", "Account2"]}))
-
-      subject.save
-    end
-
-    context "when accounts are to be deleted" do
-      let(:accounts) do
-        [
-          {name: "keep_me"},
-          {name: "delete_me", delete: true}
-        ]
-      end
-
-      before do
-        allow(subject.accounts[0]).to receive(:to_h) { "Account1" }
-        allow(subject.accounts[1]).to receive(:to_h) { "Account2" }
-        subject.accounts[0].mark_for_deletion!
-      end
-
-      it "does not save them" do
-        expect(JSON).to receive(:pretty_generate).
-          with(hash_including({accounts: ["Account2"]}))
-
-        subject.save
-      end
-    end
-
-    context "when file permissions are too open" do
-      context "when on UNIX" do
-        before do
-          allow(OS).to receive(:windows?) { false }
-        end
-
-        it "sets them to 0600" do
-          expect(FileUtils).to receive(:chmod).with(0o600, file_path)
-
-          subject.save
-        end
-      end
-    end
-
-    context "when the configuration file is missing" do
-      let(:file_exists) { false }
-
-      it "doesn't fail" do
-        expect do
-          subject.save
-        end.to_not raise_error
-      end
-    end
-
-    context "when on UNIX" do
-      before do
-        allow(OS).to receive(:windows?) { false }
-      end
-
-      context "when the config file permissions are too lax" do
-        let(:file_exists) { true }
-
-        before do
-          allow(Imap::Backup::Utils).to receive(:check_permissions).
-            with(file_path, 0o600).and_raise("Error")
-        end
-
-        it "fails" do
-          expect do
-            subject.save
-          end.to raise_error(RuntimeError, "Error")
-        end
-      end
-    end
-  end
-end
-
-# rubocop:enable RSpec/PredicateMatcher

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

@@ -1,44 +0,0 @@
-describe Imap::Backup::Downloader do
-  describe "#run" do
-    subject { described_class.new(folder, serializer) }
-
-    let(:body) { "blah" }
-    let(:folder) do
-      instance_double(
-        Imap::Backup::Account::Folder,
-        fetch_multi: [{uid: "111", body: body}],
-        name: "folder",
-        uids: folder_uids
-      )
-    end
-    let(:folder_uids) { %w(111 222 333) }
-    let(:serializer) do
-      instance_double(Imap::Backup::Serializer::Mbox, save: nil, uids: ["222"])
-    end
-
-    context "with fetched messages" do
-      specify "are saved" do
-        expect(serializer).to receive(:save).with("111", body)
-
-        subject.run
-      end
-    end
-
-    context "with messages which are already present" do
-      specify "are skipped" do
-        expect(serializer).to_not receive(:save).with("222", anything)
-
-        subject.run
-      end
-    end
-
-    context "with failed fetches" do
-      specify "are skipped" do
-        allow(folder).to receive(:fetch_multi) { nil }
-        expect(serializer).to_not receive(:save)
-
-        subject.run
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require "net/imap"
-
-module Imap::Backup
-  describe Logger do
-    describe ".setup_logging" do
-      let(:config) { instance_double(Configuration, debug?: debug) }
-
-      around do |example|
-        logger_previous = described_class.logger.level
-        net_imap_previous = Net::IMAP.debug
-        described_class.logger.level = 42
-        Net::IMAP.debug = 42
-        example.run
-        Net::IMAP.debug = net_imap_previous
-        described_class.logger.level = logger_previous
-      end
-
-      before do
-        allow(Configuration).to receive(:new) { config }
-        described_class.setup_logging
-      end
-
-      context "when config.debug?" do
-        let(:debug) { true }
-
-        it "sets logger level to debug" do
-          expect(described_class.logger.level).to eq(::Logger::Severity::DEBUG)
-        end
-
-        it "sets the Net::IMAP debug flag" do
-          expect(Net::IMAP.debug).to be_a(TrueClass)
-        end
-      end
-
-      context "when not config.debug?" do
-        let(:debug) { false }
-
-        it "sets logger level to error" do
-          expect(described_class.logger.level).to eq(::Logger::Severity::ERROR)
-        end
-
-        it "doesn't set the Net::IMAP debug flag" do
-          expect(Net::IMAP.debug).to be_a(FalseClass)
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require "imap/backup/migrator"
-
-module Imap::Backup
-  RSpec.describe Migrator do
-    subject { described_class.new(serializer, folder, reset: reset) }
-
-    let(:serializer) { instance_double(Serializer::MboxStore, uids: [1]) }
-    let(:folder) do
-      instance_double(
-        Account::Folder,
-        append: nil, clear: nil, create: nil, name: "name", uids: folder_uids
-      )
-    end
-    let(:folder_uids) { [] }
-    let(:reset) { false }
-    let(:messages) { [[1, message]] }
-    let(:message) { instance_double(Email::Mboxrd::Message, supplied_body: body) }
-    let(:body) { "body" }
-
-    before do
-      allow(serializer).to receive(:each_message) do
-        messages.enum_for(:each)
-      end
-    end
-
-    it "creates the folder" do
-      subject.run
-
-      expect(folder).to have_received(:create)
-    end
-
-    it "uploads messages" do
-      subject.run
-
-      expect(folder).to have_received(:append).with(message)
-    end
-
-    context "when the folder is not empty" do
-      let(:folder_uids) { [99] }
-
-      it "fails" do
-        expect do
-          subject.run
-        end.to raise_error(RuntimeError, /The destination folder 'name' is not empty/)
-      end
-
-      context "when `reset` is true" do
-        let(:reset) { true }
-
-        it "clears the folder" do
-          subject.run
-
-          expect(folder).to have_received(:clear)
-        end
-      end
-    end
-  end
-end

data/spec/unit/imap/backup/serializer/mbox_enumerator_spec.rb

@@ -1,45 +0,0 @@
-require "imap/backup/serializer/mbox_enumerator"
-
-describe Imap::Backup::Serializer::MboxEnumerator do
-  subject { described_class.new(mbox_pathname) }
-
-  let(:mbox_pathname) { "/mbox/pathname" }
-  let(:mbox_file) { instance_double(File) }
-  let(:lines) { message1 + message2 + [nil] }
-  let(:message1) do
-    [
-      "From Frida\r\n",
-      "Hello\r\n"
-    ]
-  end
-  let(:message2) do
-    [
-      "From John\r\n",
-      "Hi\r\n"
-    ]
-  end
-
-  before do
-    allow(File).to receive(:open).and_call_original
-    allow(File).to receive(:open).with(mbox_pathname, "rb").and_yield(mbox_file)
-    allow(mbox_file).to receive(:gets).and_return(*lines)
-  end
-
-  describe "#each" do
-    it "reads files as binary" do
-      expect(File).to receive(:open).with(mbox_pathname, "rb")
-      subject.each {}
-    end
-
-    it "yields messages" do
-      expect { |b| subject.each(&b) }.
-        to yield_successive_args(message1.join, message2.join)
-    end
-
-    context "without a block" do
-      it "returns an Enumerator" do
-        expect(subject.each).to be_a(Enumerator)
-      end
-    end
-  end
-end

data/spec/unit/imap/backup/serializer/mbox_spec.rb

@@ -1,222 +0,0 @@
-describe Imap::Backup::Serializer::Mbox do
-  subject { described_class.new(base_path, imap_folder) }
-
-  let(:base_path) { "/base/path" }
-  let(:store) do
-    instance_double(
-      Imap::Backup::Serializer::MboxStore,
-      add: nil,
-      rename: nil,
-      uids: nil,
-      uid_validity: existing_uid_validity,
-      "uid_validity=": nil,
-      update_uid: nil
-    )
-  end
-  let(:imap_folder) { "folder" }
-  let(:permissions) { 0o700 }
-  let(:dir_exists) { true }
-  let(:existing_uid_validity) { nil }
-
-  before do
-    allow(Imap::Backup::Utils).to receive(:make_folder)
-    allow(Imap::Backup::Utils).to receive(:mode) { permissions }
-    allow(Imap::Backup::Utils).to receive(:check_permissions) { true }
-    allow(File).to receive(:directory?) { dir_exists }
-    allow(FileUtils).to receive(:chmod)
-    allow(Imap::Backup::Serializer::MboxStore).to receive(:new) { store }
-  end
-
-  describe "folder path" do
-    context "when it has multiple elements" do
-      let(:imap_folder) { "folder/path" }
-
-      context "when the containing directory is missing" do
-        let(:dir_exists) { false }
-
-        it "is created" do
-          expect(Imap::Backup::Utils).to receive(:make_folder).
-            with(base_path, File.dirname(imap_folder), 0o700)
-
-          subject.uids
-        end
-      end
-    end
-
-    context "when permissions are incorrect" do
-      let(:permissions) { 0o777 }
-
-      it "corrects them" do
-        path = File.expand_path(File.join(base_path, File.dirname(imap_folder)))
-        expect(FileUtils).to receive(:chmod).with(0o700, path)
-
-        subject.uids
-      end
-    end
-
-    context "when permissons are correct" do
-      it "does nothing" do
-        expect(FileUtils).to_not receive(:chmod)
-
-        subject.uids
-      end
-    end
-
-    context "when it exists" do
-      it "is not created" do
-        expect(Imap::Backup::Utils).to_not receive(:make_folder).
-          with(base_path, File.dirname(imap_folder), 0o700)
-
-        subject.uids
-      end
-    end
-  end
-
-  describe "#apply_uid_validity" do
-    context "when the existing uid validity is unset" do
-      it "sets uid validity" do
-        expect(store).to receive(:uid_validity=).with("aaa")
-
-        subject.apply_uid_validity("aaa")
-      end
-
-      it "does not rename the store" do
-        expect(store).to_not receive(:rename)
-
-        subject.apply_uid_validity("aaa")
-      end
-
-      it "returns nil" do
-        expect(subject.apply_uid_validity("aaa")).to be_nil
-      end
-    end
-
-    context "when the uid validity is unchanged" do
-      let(:existing_uid_validity) { "aaa" }
-
-      it "does not set uid validity" do
-        expect(store).to_not receive(:uid_validity=)
-
-        subject.apply_uid_validity("aaa")
-      end
-
-      it "does not rename the store" do
-        expect(store).to_not receive(:rename)
-
-        subject.apply_uid_validity("aaa")
-      end
-
-      it "returns nil" do
-        expect(subject.apply_uid_validity("aaa")).to be_nil
-      end
-    end
-
-    context "when the uid validity is changed" do
-      let(:existing_uid_validity) { "bbb" }
-      let(:existing_store) do
-        instance_double(Imap::Backup::Serializer::MboxStore)
-      end
-      let(:exists) { false }
-
-      before do
-        allow(Imap::Backup::Serializer::MboxStore).
-          to receive(:new).with(anything, /bbb/) { existing_store }
-        allow(existing_store).to receive(:exist?).and_return(exists, false)
-      end
-
-      it "sets uid validity" do
-        expect(store).to receive(:uid_validity=).with("aaa")
-
-        subject.apply_uid_validity("aaa")
-      end
-
-      context "when adding the uid validity does not cause a name clash" do
-        it "renames the store, adding the existing uid validity" do
-          expect(store).to receive(:rename).with("folder-bbb")
-
-          subject.apply_uid_validity("aaa")
-        end
-
-        it "returns the new name" do
-          expect(subject.apply_uid_validity("aaa")).to eq("folder-bbb")
-        end
-      end
-
-      context "when adding the uid validity causes a name clash" do
-        let(:exists) { true }
-
-        it "renames the store, adding the existing uid validity and a digit" do
-          expect(store).to receive(:rename).with("folder-bbb-1")
-
-          subject.apply_uid_validity("aaa")
-        end
-
-        it "returns the new name" do
-          expect(subject.apply_uid_validity("aaa")).to eq("folder-bbb-1")
-        end
-      end
-    end
-  end
-
-  describe "#force_uid_validity" do
-    it "sets the uid_validity" do
-      expect(store).to receive(:uid_validity=).with("66")
-
-      subject.force_uid_validity("66")
-    end
-  end
-
-  describe "#uids" do
-    it "calls the store" do
-      expect(store).to receive(:uids)
-
-      subject.uids
-    end
-  end
-
-  describe "#load" do
-    before { allow(store).to receive(:load).with("66") { "xxx" } }
-
-    it "returns the value loaded by the store" do
-      expect(subject.load("66")).to eq("xxx")
-    end
-  end
-
-  describe "#each_message" do
-    it "calls the store" do
-      expect(store).to receive(:each_message).with([1])
-
-      subject.each_message([1])
-    end
-  end
-
-  describe "#save" do
-    it "calls the store" do
-      expect(store).to receive(:add).with("foo", "bar")
-
-      subject.save("foo", "bar")
-    end
-  end
-
-  describe "#rename" do
-    it "calls the store" do
-      expect(store).to receive(:rename).with("foo")
-
-      subject.rename("foo")
-    end
-
-    it "updates the folder name" do
-      subject.rename("foo")
-
-      expect(subject.folder).to eq("foo")
-    end
-  end
-
-  describe "#update_uid" do
-    it "calls the store" do
-      expect(store).to receive(:update_uid).with("foo", "bar")
-
-      subject.update_uid("foo", "bar")
-    end
-  end
-end