imap-backup 2.1.1 → 3.0.0

data/spec/unit/google/auth/stores/in_memory_token_store_spec.rb

@@ -0,0 +1,15 @@
+require "google/auth/stores/in_memory_token_store"
+
+describe Google::Auth::Stores::InMemoryTokenStore do
+  KEY = "key".freeze
+  VALUE = "value".freeze
+
+  subject { described_class.new }
+
+  describe "#load" do
+    it "returns an item's value" do
+      subject[KEY] = VALUE
+      expect(subject.load(KEY)).to eq(VALUE)
+    end
+  end
+end

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

@@ -1,58 +1,57 @@
-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: backup_folders,
+      server: server
     }
   end
-  let(:local_path) { "local_path" }
-  let(:backup_folders) { [self.class.folder_config] }
-  let(:username) { "username@gmail.com" }
+  let(:backup_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
 
   shared_examples "connects to IMAP" do
-    it "sets up the IMAP connection" do
-      expect(Net::IMAP).to have_received(:new)
-    end
-
     it "logs in to the imap server" do
       expect(imap).to have_received(:login)
     end
@@ -60,18 +59,21 @@ 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],
+      [:backup_folders, [FOLDER_CONFIG]],
+      [: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
 
     it "creates the path" do
+      expect(Imap::Backup::Utils).to receive(:make_folder)
+
       subject.username
-      expect(Imap::Backup::Utils).to have_received(:make_folder)
     end
   end
 
@@ -82,6 +84,61 @@ describe Imap::Backup::Account::Connection do
       expect(result).to eq(imap)
     end
 
+    it "uses the password" do
+      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
+
     include_examples "connects to IMAP"
   end
 
@@ -102,16 +159,16 @@ describe Imap::Backup::Account::Connection do
     let(:remote_uid) { "remote_uid" }
 
     before do
-      allow(Imap::Backup::Account::Folder).to receive(:new).and_return(folder)
+      allow(Imap::Backup::Account::Folder).to receive(:new) { folder }
       allow(Imap::Backup::Serializer::Mbox).to receive(:new) { serializer }
     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
@@ -135,59 +192,59 @@ 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).and_return(folder)
-        allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-          with(local_path, self.class.backup_folder).and_return(serializer)
-        subject.run_backup
-      end
-
       it "runs the downloader" do
-        expect(downloader).to have_received(:run)
+        expect(downloader).to receive(:run)
+
+        subject.run_backup
       end
 
       context "when a folder does not exist" do
         let(:exists) { false }
 
         it "does not run the downloader" do
-          expect(downloader).to_not have_received(:run)
+          expect(downloader).to_not receive(:run)
+
+          subject.run_backup
         end
       end
     end
 
     context "without supplied backup_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").and_return(folder)
+          with(subject, ROOT_NAME) { folder }
         allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-          with(local_path, "foo").and_return(serializer)
+          with(LOCAL_PATH, ROOT_NAME) { serializer }
       end
 
       context "when supplied backup_folders is nil" do
         let(:backup_folders) { nil }
 
-        before { subject.run_backup }
-
         it "runs the downloader for each folder" do
-          expect(downloader).to have_received(:run).exactly(:once)
+          expect(downloader).to receive(:run).exactly(:once)
+
+          subject.run_backup
         end
       end
 
       context "when supplied backup_folders is an empty list" do
         let(:backup_folders) { [] }
 
-        before { subject.run_backup }
-
         it "runs the downloader for each folder" do
-          expect(downloader).to have_received(:run).exactly(:once)
+          expect(downloader).to receive(:run).exactly(:once)
+
+          subject.run_backup
         end
       end
 
@@ -200,6 +257,12 @@ describe Imap::Backup::Account::Connection do
         end
       end
     end
+
+    context "when run" do
+      before { subject.run_backup }
+
+      include_examples "connects to IMAP"
+    end
   end
 
   describe "#restore" do
@@ -207,12 +270,12 @@ describe Imap::Backup::Account::Connection do
       instance_double(
         Imap::Backup::Account::Folder,
         create: nil,
-        exist?: exists,
-        name: "my_folder",
+        uids: uids,
+        name: FOLDER_NAME,
         uid_validity: uid_validity
       )
     end
-    let(:exists) { true }
+    let(:uids) { [99] }
     let(:uid_validity) { 123 }
     let(:serialized_folder) { "old name" }
     let(:uploader) do
@@ -236,9 +299,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,75 +311,90 @@ 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")))
-      subject.restore
+        and_yield(Pathname.new(File.join(LOCAL_PATH, "#{FOLDER_NAME}.imap")))
     end
 
     it "sets local uid validity" do
-      expect(serializer).
-        to have_received(:apply_uid_validity).with(uid_validity)
+      expect(serializer).to receive(:apply_uid_validity).with(uid_validity)
+
+      subject.restore
     end
 
-    context "when folders exist" do
+    context "when folders exist with contents" do
       context "when the local folder is renamed" do
         let(:new_uid_validity) { "new name" }
 
         it "creates the new folder" do
-          expect(updated_folder).to have_received(:create)
+          expect(updated_folder).to receive(:create)
+
+          subject.restore
         end
 
         it "sets the renamed folder's uid validity" do
           expect(updated_serializer).
-            to have_received(:force_uid_validity).with("new uid validity")
+            to receive(:force_uid_validity).with("new uid validity")
+
+          subject.restore
         end
 
         it "creates the uploader with updated folder and serializer" do
-          expect(updated_uploader).to have_received(:run)
+          expect(updated_uploader).to receive(:run)
+
+          subject.restore
         end
       end
 
       context "when the local folder is not renamed" do
         it "runs the uploader" do
-          expect(uploader).to have_received(:run)
+          expect(uploader).to receive(:run)
+
+          subject.restore
         end
       end
     end
 
-    context "when folders don't exist" do
-      let(:exists) { false }
+    context "when folders don't exist or are empty" do
+      let(:uids) { [] }
 
       it "creates the folder" do
-        expect(folder).to have_received(:create)
+        expect(folder).to receive(:create)
+
+        subject.restore
       end
 
-      it "sets local uid validity" do
+      it "forces local uid validity" do
+        expect(serializer).to receive(:force_uid_validity).with(uid_validity)
+
+        subject.restore
       end
 
       it "runs the uploader" do
-        expect(uploader).to have_received(:run)
+        expect(uploader).to receive(:run)
+
+        subject.restore
       end
     end
   end
 
   describe "#reconnect" do
-    before { subject.reconnect }
-
     it "disconnects from the server" do
-      expect(imap).to have_received(:disconnect)
+      expect(imap).to receive(:disconnect)
+
+      subject.reconnect
     end
 
     it "causes reconnection on future access" do
-      allow(Net::IMAP).to receive(:new) { imap }
-      subject.imap
-      expect(Net::IMAP).to have_received(:new).twice
+      expect(Net::IMAP).to receive(:new)
+
+      subject.reconnect
     end
   end
 
   describe "#disconnect" do
-    before { subject.disconnect }
-
     it "disconnects from the server" do
-      expect(imap).to have_received(:disconnect)
+      expect(imap).to receive(:disconnect)
+
+      subject.disconnect
     end
   end
 end

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

@@ -28,7 +28,7 @@ describe Imap::Backup::Account::Folder do
   describe "#uids" do
     let(:uids) { [5678, 123] }
 
-    before { allow(imap).to receive(:uid_search).and_return(uids) }
+    before { allow(imap).to receive(:uid_search) { uids } }
 
     it "lists available messages" do
       expect(subject.uids).to eq(uids.reverse)
@@ -43,6 +43,20 @@ describe Imap::Backup::Account::Folder do
         expect(subject.uids).to eq([])
       end
     end
+
+    context "with no SEARCH response in Net::IMAP" do
+      let(:no_method_error) do
+        NoMethodError.new("Somethimes SEARCH responses come out undefined")
+      end
+
+      before do
+        allow(imap).to receive(:examine).and_raise(no_method_error)
+      end
+
+      it "returns an empty array" do
+        expect(subject.uids).to eq([])
+      end
+    end
   end
 
   describe "#fetch" do
@@ -83,12 +97,6 @@ describe Imap::Backup::Account::Folder do
         expect(subject.fetch(123)).to be_nil
       end
     end
-
-    it "sets the encoding on the message" do
-      subject.fetch(123)
-
-      expect(message_body).to have_received(:force_encoding).with("utf-8")
-    end
   end
 
   describe "#folder" do
@@ -117,21 +125,22 @@ describe Imap::Backup::Account::Folder do
 
   describe "#create" do
     context "when the folder exists" do
-      before { subject.create }
-
       it "is does not create the folder" do
-        expect(imap).to_not have_received(:create)
+        expect(imap).to_not receive(:create)
+
+        subject.create
       end
     end
 
     context "when the folder doesn't exist" do
       before do
         allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
-        subject.create
       end
 
       it "is does not create the folder" do
-        expect(imap).to have_received(:create)
+        expect(imap).to receive(:create)
+
+        subject.create
       end
     end
   end
@@ -168,26 +177,27 @@ describe Imap::Backup::Account::Folder do
     let(:append_response) do
       OpenStruct.new(data: OpenStruct.new(code: OpenStruct.new(data: "1 2")))
     end
-    let(:result) { subject.append(message) }
-
-    before do
-      result
-    end
 
     it "appends the message" do
-      expect(imap).to have_received(:append)
+      expect(imap).to receive(:append)
+
+      subject.append(message)
     end
 
     it "sets the date and time" do
-      expect(imap).to have_received(:append).
+      expect(imap).to receive(:append).
         with(anything, anything, anything, message_date)
+
+      subject.append(message)
     end
 
     it "returns the new uid" do
-      expect(result).to eq(2)
+      expect(subject.append(message)).to eq(2)
     end
 
     it "set the new uid validity" do
+      subject.append(message)
+
       expect(subject.uid_validity).to eq(1)
     end
   end