imap-backup 6.0.0.rc2 → 6.0.0

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,96 +0,0 @@
-describe Imap::Backup::Downloader do
-  describe "#run" do
-    subject { described_class.new(folder, serializer, **options) }
-
-    let(:body) { "blah" }
-    let(:folder) do
-      instance_double(
-        Imap::Backup::Account::Folder,
-        fetch_multi: [{uid: "111", body: body}],
-        name: "folder",
-        uids: remote_uids
-      )
-    end
-    let(:remote_uids) { %w(111 222 333) }
-    let(:serializer) do
-      instance_double(Imap::Backup::Serializer, append: nil, uids: local_uids)
-    end
-    let(:local_uids) { ["222"] }
-    let(:options) { {} }
-
-    context "with fetched messages" do
-      specify "are saved" do
-        expect(serializer).to receive(:append).with("111", body)
-
-        subject.run
-      end
-    end
-
-    context "with messages which are already present" do
-      specify "are skipped" do
-        expect(serializer).to_not receive(:append).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(:append)
-
-        subject.run
-      end
-    end
-
-    context "when the block size is greater than one" do
-      let(:remote_uids) { %w(111 999) }
-      let(:local_uids) { [] }
-      let(:options) { {multi_fetch_size: 2} }
-
-      context "when the first fetch fails" do
-        before do
-          allow(folder).to receive(:fetch_multi).with(["111", "999"]) { nil }
-          allow(folder).to receive(:fetch_multi).with(["111"]).
-            and_return([{uid: "111", body: body}]).
-            and_return([{uid: "999", body: body}])
-
-          subject.run
-        end
-
-        it "retries fetching messages singly" do
-          expect(serializer).to have_received(:append).with("111", body)
-          expect(serializer).to have_received(:append).with("999", body)
-        end
-      end
-    end
-
-    context "when no body is returned by the fetch" do
-      let(:remote_uids) { %w(111) }
-
-      before do
-        allow(folder).to receive(:fetch_multi).with(["111"]) { [{uid: "111", body: nil}] }
-
-        subject.run
-      end
-
-      it "skips the append" do
-        expect(serializer).to_not have_received(:append)
-      end
-    end
-
-    context "when the UID is not returned by the fetch" do
-      let(:remote_uids) { %w(111) }
-
-      before do
-        allow(folder).to receive(:fetch_multi).with(["111"]) { [{uid: nil, body: body}] }
-
-        subject.run
-      end
-
-      it "skips the append" do
-        expect(serializer).to_not have_received(:append)
-      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, 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/sanitizer_spec.rb

@@ -1,42 +0,0 @@
-module Imap::Backup
-  describe Sanitizer do
-    require "stringio"
-
-    subject { described_class.new(output) }
-
-    let(:output) { StringIO.new }
-
-    describe "#puts" do
-      it "delegates to output" do
-        subject.puts("x")
-
-        expect(output.string).to eq("x\n")
-      end
-    end
-
-    describe "#write" do
-      it "delegates to output" do
-        subject.write("x")
-
-        expect(output.string).to eq("x")
-      end
-    end
-
-    describe "#print" do
-      it "removes passwords from complete lines of text" do
-        subject.print("C: RUBY99 LOGIN xx) secret!!!!\netc")
-
-        expect(output.string).to eq("C: RUBY99 LOGIN xx) [PASSWORD REDACTED]\n")
-      end
-    end
-
-    describe "#flush" do
-      it "sanitizes remaining text" do
-        subject.print("before\nC: RUBY99 LOGIN xx) secret!!!!")
-        subject.flush
-
-        expect(output.string).to eq("before\nC: RUBY99 LOGIN xx) [PASSWORD REDACTED]\n")
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Imap::Backup
-  describe Serializer::Directory do
-    subject { described_class.new("path", "relative") }
-
-    let(:windows) { false }
-
-    before do
-      allow(File).to receive(:directory?) { false }
-      allow(Utils).to receive(:make_folder)
-      allow(OS).to receive(:windows?) { windows }
-      allow(Utils).to receive(:mode) { 0o600 }
-      allow(FileUtils).to receive(:chmod)
-
-      subject.ensure_exists
-    end
-
-    describe "#ensure_exists" do
-      context "when the directory doesn't exist" do
-        it "makes the directory" do
-          expect(Utils).to have_received(:make_folder)
-        end
-      end
-
-      it "sets permissions" do
-        expect(FileUtils).to have_received(:chmod)
-      end
-
-      context "when on Windows" do
-        let(:windows) { true }
-
-        it "doesn't set permissions" do
-          expect(FileUtils).to_not have_received(:chmod)
-        end
-      end
-    end
-  end
-end