imap-backup 4.0.5 → 4.1.2

data/lib/retry_on_error.rb

@@ -5,7 +5,7 @@ module RetryOnError
   rescue *errors => e
     if tries < limit
       message = "#{e}, attempt #{tries} of #{limit}"
-      Imap::Backup.logger.debug message
+      Imap::Backup::Logger.logger.debug message
       tries += 1
       retry
     end

data/spec/features/backup_spec.rb

@@ -58,6 +58,7 @@ RSpec.describe "backup", type: :feature, docker: true do
         email3
         original_folder_uid_validity
         connection.run_backup
+        connection.disconnect
         server_rename_folder folder, new_name
       end
       let(:renamed_folder) { "#{folder}.#{original_folder_uid_validity}" }

data/spec/features/status_spec.rb

@@ -0,0 +1,43 @@
+require "features/helper"
+require "imap/backup/cli/status"
+
+RSpec.describe "status", type: :feature, docker: true do
+  include_context "imap-backup connection"
+  include_context "message-fixtures"
+
+  context "when there are non-backed-up messages" do
+    let(:options) do
+      {accounts: "address@example.org"}
+    end
+    let(:folder) { "my-stuff" }
+    let(:backup_folders) { [{name: folder}] }
+    let(:email1) { send_email folder, msg1 }
+    let(:output) { StringIO.new }
+
+    before do
+      allow(Imap::Backup::CLI::Accounts).to receive(:new) { [account] }
+      server_create_folder folder
+      email1
+    end
+
+    around do |example|
+      stdout = $stdout
+      $stdout = output
+      example.run
+      $stdout = stdout
+    end
+
+    after do
+      FileUtils.rm_rf local_backup_path
+      delete_emails folder
+      server_delete_folder folder
+      connection.disconnect
+    end
+
+    it "prints the number" do
+      Imap::Backup::CLI::Status.new(options).run
+
+      expect(output.string).to eq("address@example.org\nmy-stuff: 1\n")
+    end
+  end
+end

data/spec/features/support/email_server.rb

@@ -63,11 +63,14 @@ module EmailServerHelpers
   end
 
   def server_folders
-    root_info = imap.list("", "")[0]
-    root = root_info.name
     imap.list(root, "*")
   end
 
+  def root
+    root_info = imap.list("", "")[0]
+    root_info.name
+  end
+
   def server_create_folder(folder)
     imap.create(folder)
     imap.disconnect

data/spec/features/support/shared/connection_context.rb

@@ -2,11 +2,13 @@ shared_context "imap-backup connection" do
   let(:local_backup_path) { Dir.mktmpdir(nil, "tmp") }
   let(:default_connection) { fixture("connection") }
   let(:backup_folders) { nil }
-  let(:connection_options) do
-    default_connection.merge(
-      local_path: local_backup_path,
-      folders: backup_folders
+  let(:account) do
+    Imap::Backup::Account.new(
+      default_connection.merge(
+        local_path: local_backup_path,
+        folders: backup_folders
+      )
     )
   end
-  let(:connection) { Imap::Backup::Account::Connection.new(connection_options) }
+  let(:connection) { Imap::Backup::Account::Connection.new(account) }
 end

data/spec/support/higline_test_helpers.rb

@@ -2,7 +2,7 @@ module HighLineTestHelpers
   def prepare_highline
     @input = instance_double(IO, eof?: false, gets: "q\n")
     @output = StringIO.new
-    Imap::Backup::Configuration::Setup.highline = HighLine.new(@input, @output)
+    Imap::Backup::Setup.highline = HighLine.new(@input, @output)
     [@input, @output]
   end
 end

data/spec/support/silence_logging.rb

@@ -1,7 +1,7 @@
 def silence_logging
   RSpec.configure do |config|
     config.before(:suite) do
-      Imap::Backup.logger.level = Logger::UNKNOWN
+      Imap::Backup::Logger.logger.level = Logger::UNKNOWN
     end
   end
 end

data/spec/unit/email/provider/base_spec.rb

@@ -1,4 +1,4 @@
-describe Email::Provider::Default do
+describe Email::Provider::Base do
   describe "#options" do
     it "returns options" do
       expect(subject.options).to be_a(Hash)

data/spec/unit/email/provider_spec.rb

@@ -17,10 +17,10 @@ describe Email::Provider do
     end
 
     context "with unknown providers" do
-      it "returns a default provider" do
+      it "returns the Unknown provider" do
         result = described_class.for_address("foo@unknown.com")
 
-        expect(result).to be_a(Email::Provider::Default)
+        expect(result).to be_a(Email::Provider::Unknown)
       end
     end
   end

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

@@ -5,6 +5,7 @@ describe Imap::Backup::Account::Connection do
   FOLDER_CONFIG = {name: BACKUP_FOLDER}.freeze
   FOLDER_NAME = "my_folder".freeze
   GMAIL_IMAP_SERVER = "imap.gmail.com".freeze
+  IMAP_FOLDER = "imap_folder".freeze
   LOCAL_PATH = "local_path".freeze
   LOCAL_UID = "local_uid".freeze
   PASSWORD = "secret".freeze
@@ -12,7 +13,7 @@ describe Imap::Backup::Account::Connection do
   SERVER = "imap.example.com".freeze
   USERNAME = "username@example.com".freeze
 
-  subject { described_class.new(options) }
+  subject { described_class.new(account) }
 
   let(:client) do
     instance_double(
@@ -20,14 +21,16 @@ describe Imap::Backup::Account::Connection do
     )
   end
   let(:imap_folders) { [] }
-  let(:options) do
-    {
+  let(:account) do
+    instance_double(
+      Imap::Backup::Account,
       username: USERNAME,
       password: PASSWORD,
       local_path: LOCAL_PATH,
       folders: config_folders,
-      server: server
-    }
+      server: server,
+      connection_options: nil
+    )
   end
   let(:config_folders) { [FOLDER_CONFIG] }
   let(:root_info) do
@@ -59,21 +62,10 @@ describe Imap::Backup::Account::Connection do
   end
 
   describe "#initialize" do
-    [
-      [:username, USERNAME],
-      [:password, PASSWORD],
-      [:local_path, LOCAL_PATH],
-      [:server, SERVER]
-    ].each do |attr, expected|
-      it "expects #{attr}" do
-        expect(subject.public_send(attr)).to eq(expected)
-      end
-    end
-
     it "creates the path" do
       expect(Imap::Backup::Utils).to receive(:make_folder)
 
-      subject.username
+      subject
     end
   end
 
@@ -110,19 +102,23 @@ describe Imap::Backup::Account::Connection do
     end
   end
 
-  describe "#folders" do
+  describe "#folder_names" do
     let(:imap_folders) do
-      [BACKUP_FOLDER]
+      [IMAP_FOLDER]
     end
 
     it "returns the list of folders" do
-      expect(subject.folders).to eq([BACKUP_FOLDER])
+      expect(subject.folder_names).to eq([IMAP_FOLDER])
     end
   end
 
   describe "#status" do
     let(:folder) do
-      instance_double(Imap::Backup::Account::Folder, uids: [remote_uid])
+      instance_double(
+        Imap::Backup::Account::Folder,
+        uids: [remote_uid],
+        name: IMAP_FOLDER
+      )
     end
     let(:remote_uid) { "remote_uid" }
 
@@ -132,7 +128,7 @@ describe Imap::Backup::Account::Connection do
     end
 
     it "returns the names of folders" do
-      expect(subject.status[0][:name]).to eq(BACKUP_FOLDER)
+      expect(subject.status[0][:name]).to eq(IMAP_FOLDER)
     end
 
     it "returns local message uids" do
@@ -148,7 +144,7 @@ describe Imap::Backup::Account::Connection do
     let(:folder) do
       instance_double(
         Imap::Backup::Account::Folder,
-        name: "folder",
+        name: IMAP_FOLDER,
         exist?: exists,
         uid_validity: uid_validity
       )
@@ -159,11 +155,11 @@ describe Imap::Backup::Account::Connection do
 
     before do
       allow(Imap::Backup::Downloader).
-        to receive(:new).with(folder, serializer) { downloader }
+        to receive(:new).with(folder, serializer, anything) { downloader }
       allow(Imap::Backup::Account::Folder).to receive(:new).
         with(subject, BACKUP_FOLDER) { folder }
       allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-        with(LOCAL_PATH, BACKUP_FOLDER) { serializer }
+        with(LOCAL_PATH, IMAP_FOLDER) { serializer }
     end
 
     context "with supplied config_folders" do
@@ -257,7 +253,7 @@ describe Imap::Backup::Account::Connection do
         Imap::Backup::Account::Folder,
         create: nil,
         uids: uids,
-        name: FOLDER_NAME,
+        name: IMAP_FOLDER,
         uid_validity: uid_validity
       )
     end

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

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

@@ -1,8 +1,18 @@
 describe Imap::Backup::CLI::Local do
-  let(:list) do
-    instance_double(Imap::Backup::Configuration::List, accounts: accounts)
+  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(:accounts) { [{username: email}] }
   let(:connection) do
     instance_double(
       Imap::Backup::Account::Connection,
@@ -31,9 +41,10 @@ describe Imap::Backup::CLI::Local do
 
   before do
     allow(Kernel).to receive(:puts)
-    allow(Imap::Backup::Configuration::List).to receive(:new) { list }
+    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

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

@@ -1,50 +1,62 @@
-describe Imap::Backup::CLI::Utils do
-  let(:list) do
-    instance_double(Imap::Backup::Configuration::List, accounts: accounts)
-  end
-  let(:accounts) { [{username: email}] }
-  let(:connection) do
-    instance_double(
-      Imap::Backup::Account::Connection,
-      local_folders: local_folders
-    )
-  end
-  let(:local_folders) { [[serializer, folder]] }
-  let(:folder) do
-    instance_double(
-      Imap::Backup::Account::Folder,
-      exist?: true,
-      name: "name",
-      uid_validity: "uid_validity",
-      uids: %w(123 456)
-    )
-  end
-  let(:serializer) do
-    instance_double(
-      Imap::Backup::Serializer::Mbox,
-      uids: %w(123 789),
-      apply_uid_validity: nil,
-      save: nil
-    )
-  end
-  let(:email) { "foo@example.com" }
+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(Imap::Backup::Configuration::List).to receive(:new) { list }
-    allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
-  end
+    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)
+    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
+        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)
+      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/)
+        expect(serializer).to have_received(:save).with("456", /From: fake@email.com/)
+      end
     end
   end
 end

data/spec/unit/imap/backup/{configuration/store_spec.rb → configuration_spec.rb}

@@ -3,19 +3,21 @@ require "os"
 
 # rubocop:disable RSpec/PredicateMatcher
 
-describe Imap::Backup::Configuration::Store do
+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(:data) { {debug: debug, accounts: accounts} }
   let(:debug) { true }
-  let(:accounts) { [] }
   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::Store::CONFIGURATION_DIRECTORY", directory
+      "Imap::Backup::Configuration::CONFIGURATION_DIRECTORY", directory
     )
     allow(File).to receive(:directory?).with(directory) { directory_exists }
     allow(File).to receive(:exist?).and_call_original
@@ -48,8 +50,8 @@ describe Imap::Backup::Configuration::Store do
   end
 
   describe "#modified?" do
-    context "with accounts flagged 'modified'" do
-      let(:accounts) { [{name: "foo", modified: true}] }
+    context "with modified accounts" do
+      before { subject.accounts[0].username = "changed" }
 
       it "is true" do
         expect(subject.modified?).to be_truthy
@@ -57,7 +59,7 @@ describe Imap::Backup::Configuration::Store do
     end
 
     context "with accounts flagged 'delete'" do
-      let(:accounts) { [{name: "foo", delete: true}] }
+      before { subject.accounts[0].mark_for_deletion! }
 
       it "is true" do
         expect(subject.modified?).to be_truthy
@@ -65,8 +67,6 @@ describe Imap::Backup::Configuration::Store do
     end
 
     context "without accounts flagged 'modified'" do
-      let(:accounts) { [{name: "foo"}] }
-
       it "is false" do
         expect(subject.modified?).to be_falsey
       end
@@ -156,19 +156,14 @@ describe Imap::Backup::Configuration::Store do
       subject.save
     end
 
-    context "when accounts are modified" do
-      let(:accounts) { [{name: "foo", modified: true}] }
-
-      before { subject.save }
-
-      it "skips the 'modified' flag" do
-        expected = Marshal.load(Marshal.dump(data))
-        expected[:accounts][0].delete(:modified)
+    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(expected)
+      expect(JSON).to receive(:pretty_generate).
+        with(hash_including({accounts: ["Account1", "Account2"]}))
 
-        subject.save
-      end
+      subject.save
     end
 
     context "when accounts are to be deleted" do
@@ -179,11 +174,15 @@ describe Imap::Backup::Configuration::Store do
         ]
       end
 
-      it "does not save them" do
-        expected = Marshal.load(Marshal.dump(data))
-        expected[:accounts].pop
+      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
 
-        expect(JSON).to receive(:pretty_generate).with(expected)
+      it "does not save them" do
+        expect(JSON).to receive(:pretty_generate).
+          with(hash_including({accounts: ["Account2"]}))
 
         subject.save
       end

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

@@ -6,7 +6,7 @@ describe Imap::Backup::Downloader do
     let(:folder) do
       instance_double(
         Imap::Backup::Account::Folder,
-        fetch: body,
+        fetch_multi: [{uid: "111", body: body}],
         name: "folder",
         uids: folder_uids
       )

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

@@ -0,0 +1,48 @@
+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 "sets the Net::IMAP debug flag" do
+          expect(Net::IMAP.debug).to be_a(FalseClass)
+        end
+      end
+    end
+  end
+end