imap-backup 2.2.2 → 3.2.1

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

@@ -1,50 +1,53 @@
-describe Imap::Backup::Account::Connection do
-  def self.backup_folder
-    "backup_folder"
-  end
+require "ostruct"
 
-  def self.folder_config
-    {name: backup_folder}
-  end
+describe Imap::Backup::Account::Connection do
+  BACKUP_FOLDER = "backup_folder".freeze
+  FOLDER_CONFIG = {name: BACKUP_FOLDER}.freeze
+  FOLDER_NAME = "my_folder".freeze
+  GMAIL_IMAP_SERVER = "imap.gmail.com".freeze
+  LOCAL_PATH = "local_path".freeze
+  LOCAL_UID = "local_uid".freeze
+  PASSWORD = "secret".freeze
+  ROOT_NAME = "foo".freeze
+  SERVER = "imap.example.com".freeze
+  USERNAME = "username@example.com".freeze
 
   subject { described_class.new(options) }
 
   let(:imap) do
-    instance_double(Net::IMAP, login: nil, disconnect: nil)
+    instance_double(Net::IMAP, authenticate: nil, login: nil, disconnect: nil)
   end
   let(:imap_folders) { [] }
   let(:options) do
     {
-      username: username,
-      password: "password",
-      local_path: local_path,
-      folders: backup_folders
+      username: USERNAME,
+      password: PASSWORD,
+      local_path: LOCAL_PATH,
+      folders: config_folders,
+      server: server
     }
   end
-  let(:local_path) { "local_path" }
-  let(:backup_folders) { [self.class.folder_config] }
-  let(:username) { "username@gmail.com" }
+  let(:config_folders) { [FOLDER_CONFIG] }
   let(:root_info) do
-    instance_double(Net::IMAP::MailboxList, name: root_name)
+    instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)
   end
-  let(:root_name) { "foo" }
   let(:serializer) do
     instance_double(
       Imap::Backup::Serializer::Mbox,
       folder: serialized_folder,
       force_uid_validity: nil,
       apply_uid_validity: new_uid_validity,
-      uids: [local_uid]
+      uids: [LOCAL_UID]
     )
   end
   let(:serialized_folder) { nil }
+  let(:server) { SERVER }
   let(:new_uid_validity) { nil }
-  let(:local_uid) { "local_uid" }
 
   before do
     allow(Net::IMAP).to receive(:new) { imap }
     allow(imap).to receive(:list).with("", "") { [root_info] }
-    allow(imap).to receive(:list).with(root_name, "*") { imap_folders }
+    allow(imap).to receive(:list).with(ROOT_NAME, "*") { imap_folders }
     allow(Imap::Backup::Utils).to receive(:make_folder)
   end
 
@@ -56,12 +59,13 @@ describe Imap::Backup::Account::Connection do
 
   describe "#initialize" do
     [
-      [:username, "username@gmail.com"],
-      [:local_path, "local_path"],
-      [:backup_folders, [folder_config]]
+      [:username, USERNAME],
+      [:password, PASSWORD],
+      [:local_path, LOCAL_PATH],
+      [:server, SERVER]
     ].each do |attr, expected|
       it "expects #{attr}" do
-        expect(subject.send(attr)).to eq(expected)
+        expect(subject.public_send(attr)).to eq(expected)
       end
     end
 
@@ -73,22 +77,106 @@ describe Imap::Backup::Account::Connection do
   end
 
   describe "#imap" do
-    let!(:result) { subject.imap }
+    let(:result) { subject.imap }
 
     it "returns the IMAP connection" do
       expect(result).to eq(imap)
     end
 
-    include_examples "connects to IMAP"
+    it "uses the password" do
+      result
+
+      expect(imap).to have_received(:login).with(USERNAME, PASSWORD)
+    end
+
+    context "with the GMail IMAP server" do
+      ACCESS_TOKEN = "access_token".freeze
+
+      let(:server) { GMAIL_IMAP_SERVER }
+      let(:refresh_token) { true }
+      let(:result) { nil }
+      let(:authenticator) do
+        instance_double(
+          Gmail::Authenticator,
+          credentials: credentials
+        )
+      end
+      let(:credentials) { OpenStruct.new(access_token: ACCESS_TOKEN) }
+
+      before do
+        allow(Gmail::Authenticator).
+          to receive(:refresh_token?) { refresh_token }
+        allow(Gmail::Authenticator).
+          to receive(:new).
+            with(email: USERNAME, token: PASSWORD) { authenticator }
+      end
+
+      context "when the password is our copy of a GMail refresh token" do
+        it "uses the OAuth2 access_token to authenticate" do
+          subject.imap
+
+          expect(imap).to have_received(:authenticate).with(
+            "XOAUTH2", USERNAME, ACCESS_TOKEN
+          )
+        end
+
+        context "when the refresh token is invalid" do
+          let(:credentials) { nil }
+
+          it "raises" do
+            expect { subject.imap }.to raise_error(String)
+          end
+        end
+      end
+
+      context "when the password is not our copy of a GMail refresh token" do
+        let(:refresh_token) { false }
+
+        it "uses the password" do
+          subject.imap
+
+          expect(imap).to have_received(:login).with(USERNAME, PASSWORD)
+        end
+      end
+    end
+
+    context "when the first login attempt fails" do
+      before do
+        outcomes = [-> { raise EOFError }, -> { true }]
+        allow(imap).to receive(:login) { outcomes.shift.call }
+      end
+
+      it "retries" do
+        subject.imap
+
+        expect(imap).to have_received(:login).twice
+      end
+    end
+
+    context "when run" do
+      before { subject.imap }
+
+      include_examples "connects to IMAP"
+    end
   end
 
   describe "#folders" do
     let(:imap_folders) do
-      [instance_double(Net::IMAP::MailboxList)]
+      [instance_double(Net::IMAP::MailboxList, name: BACKUP_FOLDER)]
     end
 
     it "returns the list of folders" do
-      expect(subject.folders).to eq(imap_folders)
+      expect(subject.folders).to eq([BACKUP_FOLDER])
+    end
+
+    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.folders).to eq(["Gelöscht"])
+      end
     end
   end
 
@@ -104,11 +192,11 @@ describe Imap::Backup::Account::Connection do
     end
 
     it "returns the names of folders" do
-      expect(subject.status[0][:name]).to eq(self.class.backup_folder)
+      expect(subject.status[0][:name]).to eq(BACKUP_FOLDER)
     end
 
     it "returns local message uids" do
-      expect(subject.status[0][:local]).to eq([local_uid])
+      expect(subject.status[0][:local]).to eq([LOCAL_UID])
     end
 
     it "retrieves the available uids" do
@@ -132,16 +220,13 @@ describe Imap::Backup::Account::Connection do
     before do
       allow(Imap::Backup::Downloader).
         to receive(:new).with(folder, serializer) { 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 }
     end
 
-    context "with supplied backup_folders" do
-      before do
-        allow(Imap::Backup::Account::Folder).to receive(:new).
-          with(subject, self.class.backup_folder) { folder }
-        allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-          with(local_path, self.class.backup_folder) { serializer }
-      end
-
+    context "with supplied config_folders" do
       it "runs the downloader" do
         expect(downloader).to receive(:run)
 
@@ -159,20 +244,20 @@ describe Imap::Backup::Account::Connection do
       end
     end
 
-    context "without supplied backup_folders" do
+    context "without supplied config_folders" do
       let(:imap_folders) do
-        [instance_double(Net::IMAP::MailboxList, name: "foo")]
+        [instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)]
       end
 
       before do
         allow(Imap::Backup::Account::Folder).to receive(:new).
-          with(subject, "foo") { folder }
+          with(subject, ROOT_NAME) { folder }
         allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-          with(local_path, "foo") { serializer }
+          with(LOCAL_PATH, ROOT_NAME) { serializer }
       end
 
-      context "when supplied backup_folders is nil" do
-        let(:backup_folders) { nil }
+      context "when supplied config_folders is nil" do
+        let(:config_folders) { nil }
 
         it "runs the downloader for each folder" do
           expect(downloader).to receive(:run).exactly(:once)
@@ -181,8 +266,8 @@ describe Imap::Backup::Account::Connection do
         end
       end
 
-      context "when supplied backup_folders is an empty list" do
-        let(:backup_folders) { [] }
+      context "when supplied config_folders is an empty list" do
+        let(:config_folders) { [] }
 
         it "runs the downloader for each folder" do
           expect(downloader).to receive(:run).exactly(:once)
@@ -192,14 +277,22 @@ describe Imap::Backup::Account::Connection do
       end
 
       context "when the imap server doesn't return folders" do
-        let(:backup_folders) { nil }
+        let(:config_folders) { nil }
         let(:imap_folders) { nil }
 
-        it "does not fail" do
-          expect { subject.run_backup }.to_not raise_error
+        it "fails" do
+          expect do
+            subject.run_backup
+          end.to raise_error(RuntimeError, /Unable to get folder list/)
         end
       end
     end
+
+    context "when run" do
+      before { subject.run_backup }
+
+      include_examples "connects to IMAP"
+    end
   end
 
   describe "#restore" do
@@ -208,7 +301,7 @@ describe Imap::Backup::Account::Connection do
         Imap::Backup::Account::Folder,
         create: nil,
         uids: uids,
-        name: "my_folder",
+        name: FOLDER_NAME,
         uid_validity: uid_validity
       )
     end
@@ -236,9 +329,9 @@ describe Imap::Backup::Account::Connection do
 
     before do
       allow(Imap::Backup::Account::Folder).to receive(:new).
-        with(subject, "my_folder") { folder }
+        with(subject, FOLDER_NAME) { folder }
       allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-        with(anything, "my_folder") { serializer }
+        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).
@@ -248,7 +341,7 @@ describe Imap::Backup::Account::Connection do
       allow(Imap::Backup::Uploader).to receive(:new).
         with(updated_folder, updated_serializer) { updated_uploader }
       allow(Pathname).to receive(:glob).
-        and_yield(Pathname.new(File.join(local_path, "my_folder.imap")))
+        and_yield(Pathname.new(File.join(LOCAL_PATH, "#{FOLDER_NAME}.imap")))
     end
 
     it "sets local uid validity" do

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

@@ -1,7 +1,10 @@
 # rubocop:disable RSpec/PredicateMatcher
 
 describe Imap::Backup::Account::Folder do
-  subject { described_class.new(connection, "my_folder") }
+  FOLDER_NAME = "Gelöscht".freeze
+  ENCODED_FOLDER_NAME = "Gel&APY-scht".freeze
+
+  subject { described_class.new(connection, FOLDER_NAME) }
 
   let(:imap) do
     instance_double(
@@ -16,7 +19,7 @@ describe Imap::Backup::Account::Folder do
     instance_double(Imap::Backup::Account::Connection, imap: imap)
   end
   let(:missing_mailbox_data) do
-    OpenStruct.new(text: "Unknown Mailbox: my_folder")
+    OpenStruct.new(text: "Unknown Mailbox: #{FOLDER_NAME}")
   end
   let(:missing_mailbox_response) { OpenStruct.new(data: missing_mailbox_data) }
   let(:missing_mailbox_error) do
@@ -36,7 +39,8 @@ describe Imap::Backup::Account::Folder do
 
     context "with missing mailboxes" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "returns an empty array" do
@@ -50,7 +54,8 @@ describe Imap::Backup::Account::Folder do
       end
 
       before do
-        allow(imap).to receive(:examine).and_raise(no_method_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "returns an empty array" do
@@ -82,7 +87,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the mailbox doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "is nil" do
@@ -97,11 +103,28 @@ describe Imap::Backup::Account::Folder do
         expect(subject.fetch(123)).to be_nil
       end
     end
+
+    context "when the first fetch_uid attempts fail" do
+      before do
+        outcomes = [-> { raise EOFError }, -> { [fetch_data_item] }]
+        allow(imap).to receive(:uid_fetch) { outcomes.shift.call }
+      end
+
+      it "retries" do
+        subject.fetch(123)
+
+        expect(imap).to have_received(:uid_fetch).twice
+      end
+
+      it "succeeds" do
+        subject.fetch(123)
+      end
+    end
   end
 
   describe "#folder" do
     it "is the name" do
-      expect(subject.folder).to eq("my_folder")
+      expect(subject.folder).to eq(FOLDER_NAME)
     end
   end
 
@@ -114,7 +137,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "is false" do
@@ -134,14 +158,21 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
-      it "is does not create the folder" do
+      it "creates the folder" do
         expect(imap).to receive(:create)
 
         subject.create
       end
+
+      it "encodes the folder name" do
+        expect(imap).to receive(:create).with(ENCODED_FOLDER_NAME)
+
+        subject.create
+      end
     end
   end
 
@@ -154,7 +185,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "raises an error" do

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

@@ -1,13 +1,16 @@
-# rubocop:disable RSpec/NestedGroups
-
 describe Imap::Backup::Configuration::Account do
-  describe "#initialize" do
-    subject { described_class.new(store, account, highline) }
+  ACCOUNT = "account".freeze
+  GMAIL_IMAP_SERVER = "imap.gmail.com".freeze
+  HIGHLINE = "highline".freeze
+  STORE = "store".freeze
+
+  subject { described_class.new(store, account, highline) }
 
-    let(:store) { "store" }
-    let(:account) { "account" }
-    let(:highline) { "highline" }
+  let(:account) { ACCOUNT }
+  let(:highline) { HIGHLINE }
+  let(:store) { STORE }
 
+  describe "#initialize" do
     [:store, :account, :highline].each do |param|
       it "expects #{param}" do
         expect(subject.send(param)).to eq(send(param))
@@ -16,8 +19,6 @@ describe Imap::Backup::Configuration::Account do
   end
 
   describe "#run" do
-    subject { described_class.new(store, account, highline) }
-
     let(:highline_menu_class) do
       Class.new do
         attr_reader :choices
@@ -46,7 +47,7 @@ describe Imap::Backup::Configuration::Account do
     let(:account) do
       {
         username: existing_email,
-        server: existing_server,
+        server: current_server,
         local_path: "/backup/path",
         folders: [{name: "my_folder"}],
         password: existing_password
@@ -60,7 +61,7 @@ describe Imap::Backup::Configuration::Account do
     end
     let(:existing_email) { "user@example.com" }
     let(:new_email) { "foo@example.com" }
-    let(:existing_server) { "imap.example.com" }
+    let(:current_server) { "imap.example.com" }
     let(:existing_password) { "password" }
     let(:other_email) { "other@example.com" }
     let(:other_existing_path) { "/other/existing/path" }
@@ -136,7 +137,7 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    describe "email" do
+    describe "choosing 'modify email'" do
       before do
         allow(Imap::Backup::Configuration::Asker).
           to receive(:email) { new_email }
@@ -146,7 +147,7 @@ describe Imap::Backup::Configuration::Account do
 
       context "when the server is blank" do
         [
-          ["GMail", "foo@gmail.com", "imap.gmail.com"],
+          ["GMail", "foo@gmail.com", GMAIL_IMAP_SERVER],
           ["Fastmail", "bar@fastmail.fm", "imap.fastmail.com"],
           ["Fastmail", "bar@fastmail.com", "imap.fastmail.com"]
         ].each do |service, email, expected|
@@ -154,7 +155,7 @@ describe Imap::Backup::Configuration::Account do
             let(:new_email) { email }
 
             context "with nil" do
-              let(:existing_server) { nil }
+              let(:current_server) { nil }
 
               it "sets a default server" do
                 expect(account[:server]).to eq(expected)
@@ -162,7 +163,7 @@ describe Imap::Backup::Configuration::Account do
             end
 
             context "with an empty string" do
-              let(:existing_server) { "" }
+              let(:current_server) { "" }
 
               it "sets a default server" do
                 expect(account[:server]).to eq(expected)
@@ -172,7 +173,7 @@ describe Imap::Backup::Configuration::Account do
         end
 
         context "when the domain is unrecognized" do
-          let(:existing_server) { nil }
+          let(:current_server) { nil }
           let(:provider) do
             instance_double(Email::Provider, provider: :default)
           end
@@ -211,12 +212,18 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    describe "password" do
+    describe "choosing 'modify password'" do
       let(:new_password) { "new_password" }
+      let(:gmail_oauth2) do
+        instance_double(Imap::Backup::Configuration::GmailOauth2, run: nil)
+      end
 
       before do
         allow(Imap::Backup::Configuration::Asker).
           to receive(:password) { new_password }
+        allow(Imap::Backup::Configuration::GmailOauth2).
+          to receive(:new).
+            with(account) { gmail_oauth2 }
         subject.run
         menu.choices["modify password"].call
       end
@@ -238,9 +245,17 @@ describe Imap::Backup::Configuration::Account do
 
         include_examples "it doesn't flag the account as modified"
       end
+
+      context "when the server is for GMail" do
+        let(:current_server) { GMAIL_IMAP_SERVER }
+
+        it "sets up GMail OAuth2" do
+          expect(gmail_oauth2).to have_received(:run)
+        end
+      end
     end
 
-    describe "server" do
+    describe "choosing 'modify server'" do
       let(:server) { "server" }
 
       before do
@@ -258,7 +273,7 @@ describe Imap::Backup::Configuration::Account do
       include_examples "it flags the account as modified"
     end
 
-    describe "backup_path" do
+    describe "choosing 'modify backup path'" do
       let(:new_backup_path) { "/new/path" }
 
       before do
@@ -296,7 +311,7 @@ describe Imap::Backup::Configuration::Account do
       include_examples "it flags the account as modified"
     end
 
-    describe "folders" do
+    describe "choosing 'choose backup folders'" do
       let(:chooser) do
         instance_double(Imap::Backup::Configuration::FolderChooser, run: nil)
       end
@@ -313,7 +328,7 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    describe "connection test" do
+    describe "choosing 'test connection'" do
       before do
         allow(Imap::Backup::Configuration::ConnectionTester).
           to receive(:test) { "All fine" }
@@ -328,7 +343,7 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    describe "deletion" do
+    describe "choosing 'delete'" do
       let(:confirmed) { true }
 
       before do
@@ -355,5 +370,3 @@ describe Imap::Backup::Configuration::Account do
     end
   end
 end
-
-# rubocop:enable RSpec/NestedGroups