imap-backup 5.0.0 → 6.0.0.rc2

data/spec/features/backup_spec.rb

@@ -1,28 +1,28 @@
 require "features/helper"
 
-RSpec.describe "backup", type: :feature, docker: true do
+RSpec.describe "backup", type: :aruba, docker: true do
   include_context "imap-backup connection"
   include_context "message-fixtures"
 
+  let(:local_backup_path) { File.expand_path("~/backup") }
+  let(:backup_folders) { [{name: folder}] }
+  let(:folder) { "my-stuff" }
   let(:messages_as_mbox) do
     message_as_mbox_entry(msg1) + message_as_mbox_entry(msg2)
   end
-  let(:folder) { "my-stuff" }
-  let(:email1) { send_email folder, msg1 }
-  let(:email2) { send_email folder, msg2 }
+
   let!(:pre) {}
   let!(:setup) do
     server_create_folder folder
-    email1
-    email2
-    connection.run_backup
+    send_email folder, msg1
+    send_email folder, msg2
+    create_config(accounts: [account.to_h])
+
+    run_command_and_stop("imap-backup backup")
   end
 
   after do
-    FileUtils.rm_rf local_backup_path
-    delete_emails folder
     server_delete_folder folder
-    connection.disconnect
   end
 
   it "downloads messages" do
@@ -51,17 +51,16 @@ RSpec.describe "backup", type: :feature, docker: true do
 
     context "when uid_validity does not match" do
       let(:new_name) { "NEWNAME" }
-      let(:email3) { send_email folder, msg3 }
       let(:original_folder_uid_validity) { server_uid_validity(folder) }
       let!(:pre) do
         server_create_folder folder
-        email3
+        send_email folder, msg3
         original_folder_uid_validity
         connection.run_backup
         connection.disconnect
         server_rename_folder folder, new_name
       end
-      let(:renamed_folder) { "#{folder}.#{original_folder_uid_validity}" }
+      let(:renamed_folder) { "#{folder}-#{original_folder_uid_validity}" }
 
       after do
         server_delete_folder new_name
@@ -71,37 +70,31 @@ RSpec.describe "backup", type: :feature, docker: true do
         expect(mbox_content(renamed_folder)).to eq(message_as_mbox_entry(msg3))
       end
 
+      it "renames the old metadata file" do
+        expect(imap_parsed(renamed_folder)).to be_a Hash
+      end
+
       it "downloads messages" do
         expect(mbox_content(folder)).to eq(messages_as_mbox)
       end
 
+      it "creates a metadata file" do
+        expect(imap_parsed(folder)).to be_a Hash
+      end
+
       context "when a renamed local backup exists" do
         let!(:pre) do
           super()
+          create_directory local_backup_path
           File.write(imap_path(renamed_folder), "existing imap")
           File.write(mbox_path(renamed_folder), "existing mbox")
         end
 
         it "moves the old backup to a uniquely named directory" do
-          renamed = "#{folder}.#{original_folder_uid_validity}.1"
+          renamed = "#{folder}-#{original_folder_uid_validity}-1"
           expect(mbox_content(renamed)).to eq(message_as_mbox_entry(msg3))
         end
       end
     end
-
-    context "when an unversioned .imap file is found" do
-      let!(:pre) do
-        File.open(imap_path(folder), "w") { |f| f.write "old format imap" }
-        File.open(mbox_path(folder), "w") { |f| f.write "old format emails" }
-      end
-
-      it "replaces the .imap file with a versioned JSON file" do
-        expect(imap_metadata[:uids]).to eq(folder_uids)
-      end
-
-      it "does the download" do
-        expect(mbox_content(folder)).to eq(messages_as_mbox)
-      end
-    end
   end
 end

data/spec/features/restore_spec.rb

@@ -1,9 +1,11 @@
 require "features/helper"
 
-RSpec.describe "restore", type: :feature, docker: true do
+RSpec.describe "restore", type: :aruba, docker: true do
   include_context "imap-backup connection"
   include_context "message-fixtures"
 
+  let(:local_backup_path) { File.expand_path("~/backup") }
+  let(:folder) { "my-stuff" }
   let(:messages_as_mbox) do
     message_as_mbox_entry(msg1) + message_as_mbox_entry(msg2)
   end
@@ -12,19 +14,19 @@ RSpec.describe "restore", type: :feature, docker: true do
   end
   let(:message_uids) { [msg1[:uid], msg2[:uid]] }
   let(:existing_imap_content) { imap_data(uid_validity, message_uids).to_json }
-  let(:folder) { "my-stuff" }
   let(:uid_validity) { 1234 }
 
   let!(:pre) {}
   let!(:setup) do
+    create_directory local_backup_path
     File.write(imap_path(folder), existing_imap_content)
     File.write(mbox_path(folder), messages_as_mbox)
-    connection.restore
+    create_config(accounts: [account.to_h])
+
+    run_command_and_stop("imap-backup restore #{account.username}")
   end
   let(:cleanup) do
-    FileUtils.rm_rf local_backup_path
     server_delete_folder folder
-    connection.disconnect
   end
 
   after { cleanup }
@@ -92,7 +94,7 @@ RSpec.describe "restore", type: :feature, docker: true do
       end
 
       context "when the folder has content" do
-        let(:new_folder) { "#{folder}.#{uid_validity}" }
+        let(:new_folder) { "#{folder}-#{uid_validity}" }
         let(:cleanup) do
           server_delete_folder new_folder
           super()

data/spec/features/support/aruba.rb

@@ -1,7 +1,11 @@
 require "aruba/rspec"
 
+require_relative "backup_directory"
+require "imap/backup/serializer/mbox"
+
 Aruba.configure do |config|
   config.home_directory = File.expand_path("./tmp/home")
+  config.allow_absolute_paths = true
 end
 
 module ConfigurationHelpers
@@ -33,10 +37,10 @@ module StoreHelpers
     account = config.accounts.find { |a| a.username == email }
     raise "Account not found" if !account
     FileUtils.mkdir_p account.local_path
-    store = Imap::Backup::Serializer::MboxStore.new(account.local_path, folder)
-    store.uid_validity = "42" if !store.uid_validity
+    serializer = Imap::Backup::Serializer.new(account.local_path, folder)
+    serializer.force_uid_validity("42") if !serializer.uid_validity
     serialized = to_serialized(from: from, subject: subject, body: body)
-    store.add(uid, serialized)
+    serializer.append uid, serialized
   end
 
   def to_serialized(from:, subject:, body:)
@@ -58,11 +62,16 @@ end
 RSpec.configure do |config|
   config.include ConfigurationHelpers, type: :aruba
   config.include StoreHelpers, type: :aruba
+  config.include BackupDirectoryHelpers, type: :aruba
 
   config.before(:suite) do
     FileUtils.rm_rf "./tmp/home"
   end
 
+  config.before(:example, type: :aruba) do
+    set_environment_variable("COVERAGE", "aruba")
+  end
+
   config.after do
     FileUtils.rm_rf "./tmp/home"
   end

data/spec/features/support/backup_directory.rb

@@ -41,7 +41,3 @@ module BackupDirectoryHelpers
     JSON.parse(imap_content(name), symbolize_names: true)
   end
 end
-
-RSpec.configure do |config|
-  config.include BackupDirectoryHelpers, type: :feature
-end

data/spec/features/support/email_server.rb

@@ -87,7 +87,6 @@ module EmailServerHelpers
     imap.delete folder
     imap.disconnect
   rescue StandardError => e
-    puts e.to_s
   ensure
     @imap = nil
   end

data/spec/spec_helper.rb

@@ -1,18 +1,13 @@
-require "codeclimate-test-reporter"
 require "rspec"
 
-CodeClimate::TestReporter.start
+$LOAD_PATH << File.expand_path("../lib", __dir__)
 
-spec_path = File.dirname(__FILE__)
-$LOAD_PATH << File.expand_path("../lib", spec_path)
-
-support_glob = File.join(spec_path, "support", "**", "*.rb")
+support_glob = File.join(__dir__, "support", "**", "*.rb")
 Dir[support_glob].sort.each { |f| require f }
 
 require "simplecov"
-SimpleCov.start do
-  add_filter "/spec/"
-end
+
+SimpleCov.command_name "RSpec tests"
 
 require "imap/backup"
 require "imap/backup/cli"

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

@@ -24,21 +24,24 @@ describe Imap::Backup::Account::Connection do
   let(:account) do
     instance_double(
       Imap::Backup::Account,
-      username: USERNAME,
+      username: username,
       password: PASSWORD,
       local_path: LOCAL_PATH,
       folders: config_folders,
+      multi_fetch_size: multi_fetch_size,
       server: server,
       connection_options: nil
     )
   end
+  let(:username) { USERNAME }
   let(:config_folders) { [FOLDER_CONFIG] }
+  let(:multi_fetch_size) { 1 }
   let(:root_info) do
     instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)
   end
   let(:serializer) do
     instance_double(
-      Imap::Backup::Serializer::Mbox,
+      Imap::Backup::Serializer,
       folder: serialized_folder,
       force_uid_validity: nil,
       apply_uid_validity: new_uid_validity,
@@ -87,6 +90,23 @@ describe Imap::Backup::Account::Connection do
       end
     end
 
+    context "when the provider is Apple" do
+      let(:username) { "user@mac.com" }
+      let(:apple_client) do
+        instance_double(
+          Imap::Backup::Client::AppleMail, login: nil
+        )
+      end
+
+      before do
+        allow(Imap::Backup::Client::AppleMail).to receive(:new) { apple_client }
+      end
+
+      it "returns the Apple client" do
+        expect(result).to eq(apple_client)
+      end
+    end
+
     context "when run" do
       before { subject.client }
 
@@ -116,7 +136,7 @@ describe Imap::Backup::Account::Connection do
 
     before do
       allow(Imap::Backup::Account::Folder).to receive(:new) { folder }
-      allow(Imap::Backup::Serializer::Mbox).to receive(:new) { serializer }
+      allow(Imap::Backup::Serializer).to receive(:new) { serializer }
     end
 
     it "creates the path" do
@@ -150,16 +170,24 @@ describe Imap::Backup::Account::Connection do
     let(:exists) { true }
     let(:uid_validity) { 123 }
     let(:downloader) { instance_double(Imap::Backup::Downloader, run: nil) }
+    let(:multi_fetch_size) { 10 }
 
     before do
       allow(Imap::Backup::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).
+      allow(Imap::Backup::Serializer).to receive(:new).
         with(LOCAL_PATH, IMAP_FOLDER) { serializer }
     end
 
+    it "passes the multi_fetch_size" do
+      subject.run_backup
+
+      expect(Imap::Backup::Downloader).to have_received(:new).
+        with(anything, anything, {multi_fetch_size: 10})
+    end
+
     context "with supplied config_folders" do
       it "runs the downloader" do
         expect(downloader).to receive(:run)
@@ -184,7 +212,7 @@ describe Imap::Backup::Account::Connection do
       before do
         allow(Imap::Backup::Account::Folder).to receive(:new).
           with(subject, ROOT_NAME) { folder }
-        allow(Imap::Backup::Serializer::Mbox).to receive(:new).
+        allow(Imap::Backup::Serializer).to receive(:new).
           with(LOCAL_PATH, ROOT_NAME) { serializer }
       end
 
@@ -273,18 +301,18 @@ describe Imap::Backup::Account::Connection do
     end
     let(:updated_serializer) do
       instance_double(
-        Imap::Backup::Serializer::Mbox, force_uid_validity: nil
+        Imap::Backup::Serializer, force_uid_validity: nil
       )
     end
 
     before do
       allow(Imap::Backup::Account::Folder).to receive(:new).
         with(subject, FOLDER_NAME) { folder }
-      allow(Imap::Backup::Serializer::Mbox).to receive(:new).
+      allow(Imap::Backup::Serializer).to receive(:new).
         with(anything, FOLDER_NAME) { serializer }
       allow(Imap::Backup::Account::Folder).to receive(:new).
         with(subject, "new name") { updated_folder }
-      allow(Imap::Backup::Serializer::Mbox).to receive(:new).
+      allow(Imap::Backup::Serializer).to receive(:new).
         with(anything, "new name") { updated_serializer }
       allow(Imap::Backup::Uploader).to receive(:new).
         with(folder, serializer) { uploader }

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

@@ -64,26 +64,36 @@ describe Imap::Backup::Account::Folder 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" do
+  describe "#fetch_multi" do
     let(:message_body) { instance_double(String, force_encoding: nil) }
-    let(:attributes) { {"BODY[]" => message_body, "other" => "xxx"} }
+    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 message" do
-      expect(subject.fetch(123)).to eq(message_body)
+    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(123)).to be_nil
+        expect(subject.fetch_multi([123])).to be_nil
       end
     end
 
@@ -94,15 +104,7 @@ describe Imap::Backup::Account::Folder do
       end
 
       it "is nil" do
-        expect(subject.fetch(123)).to be_nil
-      end
-    end
-
-    context "when the response doesn't include 'BODY[]'" do
-      let(:attributes) { {} }
-
-      it "is nil" do
-        expect(subject.fetch(123)).to be_nil
+        expect(subject.fetch_multi([123])).to be_nil
       end
     end
 
@@ -113,13 +115,13 @@ describe Imap::Backup::Account::Folder do
       end
 
       it "retries" do
-        subject.fetch(123)
+        subject.fetch_multi([123])
 
         expect(client).to have_received(:uid_fetch).twice
       end
 
       it "succeeds" do
-        subject.fetch(123)
+        subject.fetch_multi([123])
       end
     end
   end

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

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