imap-backup 4.0.1 → 4.0.5

data/spec/features/restore_spec.rb

@@ -152,7 +152,7 @@ RSpec.describe "restore", type: :feature, docker: true do
     it "maintains encodings" do
       message =
         server_messages(folder).
-        first["RFC822"]
+        first["BODY[]"]
 
       expect(message).to eq(server_message)
     end

data/spec/features/support/email_server.rb

@@ -1,5 +1,5 @@
 module EmailServerHelpers
-  REQUESTED_ATTRIBUTES = %w(RFC822 FLAGS INTERNALDATE).freeze
+  REQUESTED_ATTRIBUTES = ["BODY[]"].freeze
   DEFAULT_EMAIL = "address@example.org".freeze
 
   def send_email(folder, options)
@@ -28,7 +28,7 @@ module EmailServerHelpers
   end
 
   def server_message_to_body(message)
-    message["RFC822"]
+    message["BODY[]"]
   end
 
   def server_fetch_email(folder, uid)

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

@@ -0,0 +1,7 @@
+describe Email::Provider::AppleMail do
+  describe "#host" do
+    it "returns host" do
+      expect(subject.host).to eq("imap.mail.me.com")
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+describe Email::Provider::Default do
+  describe "#options" do
+    it "returns options" do
+      expect(subject.options).to be_a(Hash)
+    end
+
+    it "forces TLSv1_2" do
+      expect(subject.options[:ssl][:ssl_version]).to eq(:TLSv1_2)
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+describe Email::Provider::Fastmail do
+  describe "#host" do
+    it "returns host" do
+      expect(subject.host).to eq("imap.fastmail.com")
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+describe Email::Provider::GMail do
+  describe "#host" do
+    it "returns host" do
+      expect(subject.host).to eq("imap.gmail.com")
+    end
+  end
+end

data/spec/unit/email/provider_spec.rb

@@ -1,40 +1,27 @@
 describe Email::Provider do
-  subject { described_class.new(:gmail) }
-
   describe ".for_address" do
     context "with known providers" do
       [
-        ["gmail.com", :gmail],
-        ["fastmail.fm", :fastmail]
-      ].each do |domain, provider|
-        it "recognizes #{provider}" do
+        ["fastmail.com", "Fastmail .com", Email::Provider::Fastmail],
+        ["fastmail.fm", "Fastmail .fm", Email::Provider::Fastmail],
+        ["gmail.com", "GMail", Email::Provider::GMail],
+        ["icloud.com", "Apple Mail icloud.com", Email::Provider::AppleMail],
+        ["mac.com", "Apple Mail mac.com", Email::Provider::AppleMail],
+        ["me.com", "Apple Mail me.com", Email::Provider::AppleMail]
+      ].each do |domain, name, klass|
+        it "recognizes #{name} addresses" do
           address = "foo@#{domain}"
-          expect(described_class.for_address(address).provider).to eq(provider)
+          expect(described_class.for_address(address)).to be_a(klass)
         end
       end
     end
 
     context "with unknown providers" do
       it "returns a default provider" do
-        result = described_class.for_address("foo@unknown.com").provider
-        expect(result).to eq(:default)
-      end
-    end
-  end
-
-  describe "#options" do
-    it "returns options" do
-      expect(subject.options).to be_a(Hash)
-    end
+        result = described_class.for_address("foo@unknown.com")
 
-    it "forces TLSv1_2" do
-      expect(subject.options[:ssl][:ssl_version]).to eq(:TLSv1_2)
-    end
-  end
-
-  describe "#host" do
-    it "returns host" do
-      expect(subject.host).to eq("imap.gmail.com")
+        expect(result).to be_a(Email::Provider::Default)
+      end
     end
   end
 end

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

@@ -14,8 +14,10 @@ describe Imap::Backup::Account::Connection do
 
   subject { described_class.new(options) }
 
-  let(:imap) do
-    instance_double(Net::IMAP, authenticate: nil, login: nil, disconnect: nil)
+  let(:client) do
+    instance_double(
+      Imap::Backup::Client::Default, authenticate: nil, login: nil, disconnect: nil
+    )
   end
   let(:imap_folders) { [] }
   let(:options) do
@@ -45,15 +47,14 @@ describe Imap::Backup::Account::Connection do
   let(:new_uid_validity) { nil }
 
   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::Backup::Client::Default).to receive(:new) { client }
+    allow(client).to receive(:list) { imap_folders }
     allow(Imap::Backup::Utils).to receive(:make_folder)
   end
 
   shared_examples "connects to IMAP" do
     it "logs in to the imap server" do
-      expect(imap).to have_received(:login)
+      expect(client).to have_received(:login)
     end
   end
 
@@ -76,48 +77,34 @@ describe Imap::Backup::Account::Connection do
     end
   end
 
-  describe "#imap" do
-    let(:result) { subject.imap }
+  describe "#client" do
+    let(:result) { subject.client }
 
     it "returns the IMAP connection" do
-      expect(result).to eq(imap)
+      expect(result).to eq(client)
     end
 
     it "uses the password" do
       result
 
-      expect(imap).to have_received(:login).with(USERNAME, PASSWORD)
-    end
-
-    context "with the GMail IMAP server" do
-      let(:server) { GMAIL_IMAP_SERVER }
-      let(:refresh_token) { true }
-      let(:result) { nil }
-
-      context "when the password is not our copy of a GMail refresh token" do
-        it "uses the password" do
-          subject.imap
-
-          expect(imap).to have_received(:login).with(USERNAME, PASSWORD)
-        end
-      end
+      expect(client).to have_received(:login).with(USERNAME, PASSWORD)
     end
 
     context "when the first login attempt fails" do
       before do
         outcomes = [-> { raise EOFError }, -> { true }]
-        allow(imap).to receive(:login) { outcomes.shift.call }
+        allow(client).to receive(:login) { outcomes.shift.call }
       end
 
       it "retries" do
-        subject.imap
+        subject.client
 
-        expect(imap).to have_received(:login).twice
+        expect(client).to have_received(:login).twice
       end
     end
 
     context "when run" do
-      before { subject.imap }
+      before { subject.client }
 
       include_examples "connects to IMAP"
     end
@@ -125,22 +112,12 @@ describe Imap::Backup::Account::Connection do
 
   describe "#folders" do
     let(:imap_folders) do
-      [instance_double(Net::IMAP::MailboxList, name: BACKUP_FOLDER)]
+      [BACKUP_FOLDER]
     end
 
     it "returns the list of folders" do
       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
 
   describe "#status" do
@@ -208,9 +185,7 @@ describe Imap::Backup::Account::Connection do
     end
 
     context "without supplied config_folders" do
-      let(:imap_folders) do
-        [instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)]
-      end
+      let(:imap_folders) { [ROOT_NAME] }
 
       before do
         allow(Imap::Backup::Account::Folder).to receive(:new).
@@ -241,7 +216,7 @@ describe Imap::Backup::Account::Connection do
 
       context "when the imap server doesn't return folders" do
         let(:config_folders) { nil }
-        let(:imap_folders) { nil }
+        let(:imap_folders) { [] }
 
         it "fails" do
           expect do
@@ -389,10 +364,10 @@ describe Imap::Backup::Account::Connection do
 
   describe "#reconnect" do
     context "when the IMAP connection has been used" do
-      before { subject.imap }
+      before { subject.client }
 
       it "disconnects from the server" do
-        expect(imap).to receive(:disconnect)
+        expect(client).to receive(:disconnect)
 
         subject.reconnect
       end
@@ -400,26 +375,26 @@ describe Imap::Backup::Account::Connection do
 
     context "when the IMAP connection has not been used" do
       it "does not disconnect from the server" do
-        expect(imap).to_not receive(:disconnect)
+        expect(client).to_not receive(:disconnect)
 
         subject.reconnect
       end
     end
 
     it "causes reconnection on future access" do
-      expect(Net::IMAP).to receive(:new)
+      expect(Imap::Backup::Client::Default).to receive(:new)
 
       subject.reconnect
-      subject.imap
+      subject.client
     end
   end
 
   describe "#disconnect" do
     context "when the IMAP connection has been used" do
       it "disconnects from the server" do
-        subject.imap
+        subject.client
 
-        expect(imap).to receive(:disconnect)
+        expect(client).to receive(:disconnect)
 
         subject.disconnect
       end
@@ -427,7 +402,7 @@ describe Imap::Backup::Account::Connection do
 
     context "when the IMAP connection has not been used" do
       it "does not disconnect from the server" do
-        expect(imap).to_not receive(:disconnect)
+        expect(client).to_not receive(:disconnect)
 
         subject.disconnect
       end

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

@@ -6,9 +6,9 @@ describe Imap::Backup::Account::Folder do
 
   subject { described_class.new(connection, FOLDER_NAME) }
 
-  let(:imap) do
+  let(:client) do
     instance_double(
-      Net::IMAP,
+      Imap::Backup::Client::Default,
       append: append_response,
       create: nil,
       examine: nil,
@@ -16,7 +16,7 @@ describe Imap::Backup::Account::Folder do
     )
   end
   let(:connection) do
-    instance_double(Imap::Backup::Account::Connection, imap: imap)
+    instance_double(Imap::Backup::Account::Connection, client: client)
   end
   let(:missing_mailbox_data) do
     OpenStruct.new(text: "Unknown Mailbox: #{FOLDER_NAME}")
@@ -31,7 +31,7 @@ describe Imap::Backup::Account::Folder do
   describe "#uids" do
     let(:uids) { [5678, 123] }
 
-    before { allow(imap).to receive(:uid_search) { uids } }
+    before { allow(client).to receive(:uid_search) { uids } }
 
     it "lists available messages" do
       expect(subject.uids).to eq(uids.reverse)
@@ -39,7 +39,7 @@ describe Imap::Backup::Account::Folder do
 
     context "with missing mailboxes" do
       before do
-        allow(imap).to receive(:examine).
+        allow(client).to receive(:examine).
           with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
@@ -54,7 +54,7 @@ describe Imap::Backup::Account::Folder do
       end
 
       before do
-        allow(imap).to receive(:examine).
+        allow(client).to receive(:examine).
           with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
@@ -66,19 +66,19 @@ describe Imap::Backup::Account::Folder do
 
   describe "#fetch" do
     let(:message_body) { instance_double(String, force_encoding: nil) }
-    let(:attributes) { {"RFC822" => message_body, "other" => "xxx"} }
+    let(:attributes) { {"BODY[]" => message_body, "other" => "xxx"} }
     let(:fetch_data_item) do
       instance_double(Net::IMAP::FetchData, attr: attributes)
     end
 
-    before { allow(imap).to receive(:uid_fetch) { [fetch_data_item] } }
+    before { allow(client).to receive(:uid_fetch) { [fetch_data_item] } }
 
     it "returns the message" do
-      expect(subject.fetch(123)).to eq(attributes)
+      expect(subject.fetch(123)).to eq(message_body)
     end
 
     context "when the server responds with nothing" do
-      before { allow(imap).to receive(:uid_fetch) { nil } }
+      before { allow(client).to receive(:uid_fetch) { nil } }
 
       it "is nil" do
         expect(subject.fetch(123)).to be_nil
@@ -87,7 +87,7 @@ describe Imap::Backup::Account::Folder do
 
     context "when the mailbox doesn't exist" do
       before do
-        allow(imap).to receive(:examine).
+        allow(client).to receive(:examine).
           with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
@@ -96,7 +96,7 @@ describe Imap::Backup::Account::Folder do
       end
     end
 
-    context "when the response doesn't have RFC822" do
+    context "when the response doesn't include 'BODY[]'" do
       let(:attributes) { {} }
 
       it "is nil" do
@@ -107,13 +107,13 @@ describe Imap::Backup::Account::Folder do
     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 }
+        allow(client).to receive(:uid_fetch) { outcomes.shift.call }
       end
 
       it "retries" do
         subject.fetch(123)
 
-        expect(imap).to have_received(:uid_fetch).twice
+        expect(client).to have_received(:uid_fetch).twice
       end
 
       it "succeeds" do
@@ -137,7 +137,7 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).
+        allow(client).to receive(:examine).
           with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
@@ -150,7 +150,7 @@ describe Imap::Backup::Account::Folder do
   describe "#create" do
     context "when the folder exists" do
       it "is does not create the folder" do
-        expect(imap).to_not receive(:create)
+        expect(client).to_not receive(:create)
 
         subject.create
       end
@@ -158,18 +158,18 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).
+        allow(client).to receive(:examine).
           with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "creates the folder" do
-        expect(imap).to receive(:create)
+        expect(client).to receive(:create)
 
         subject.create
       end
 
       it "encodes the folder name" do
-        expect(imap).to receive(:create).with(ENCODED_FOLDER_NAME)
+        expect(client).to receive(:create).with(ENCODED_FOLDER_NAME)
 
         subject.create
       end
@@ -185,7 +185,7 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).
+        allow(client).to receive(:examine).
           with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
@@ -211,13 +211,13 @@ describe Imap::Backup::Account::Folder do
     end
 
     it "appends the message" do
-      expect(imap).to receive(:append)
+      expect(client).to receive(:append)
 
       subject.append(message)
     end
 
     it "sets the date and time" do
-      expect(imap).to receive(:append).
+      expect(client).to receive(:append).
         with(anything, anything, anything, message_date)
 
       subject.append(message)

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

@@ -0,0 +1,70 @@
+describe Imap::Backup::CLI::Local 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) { instance_double(Imap::Backup::Account::Folder, name: "bar") }
+  let(:serializer) do
+    instance_double(
+      Imap::Backup::Serializer::Mbox,
+      uids: uids,
+      each_message: [[123, message]]
+    )
+  end
+  let(:uids) { ["123"] }
+  let(:message) do
+    instance_double(
+      Email::Mboxrd::Message,
+      date: Date.today,
+      subject: "Ciao",
+      supplied_body: "Supplied"
+    )
+  end
+  let(:email) { "foo@example.com" }
+
+  before do
+    allow(Kernel).to receive(:puts)
+    allow(Imap::Backup::Configuration::List).to receive(:new) { list }
+    allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
+    allow(Mail).to receive(:new) { mail }
+  end
+
+  describe "accounts" do
+    it "lists configured emails" do
+      subject.accounts
+
+      expect(Kernel).to have_received(:puts).with(email)
+    end
+  end
+
+  describe "folders" do
+    it "lists downloaded folders in quotes" do
+      subject.folders(email)
+
+      expect(Kernel).to have_received(:puts).with(%("bar"))
+    end
+  end
+
+  describe "list" do
+    it "lists downloaded emails" do
+      subject.list(email, "bar")
+
+      expect(Kernel).to have_received(:puts).with(/Ciao/)
+    end
+  end
+
+  describe "show" do
+    it "prints a downloaded email" do
+      subject.show(email, "bar", "123")
+
+      expect(Kernel).to have_received(:puts).with("Supplied")
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+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" }
+
+  before do
+    allow(Imap::Backup::Configuration::List).to receive(:new) { list }
+    allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
+  end
+
+  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
+
+    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/)
+    end
+  end
+end

data/spec/unit/imap/backup/client/default_spec.rb

@@ -0,0 +1,22 @@
+describe Imap::Backup::Client::Default do
+  subject { described_class.new("server", {}) }
+
+  let(:imap) { instance_double(Net::IMAP, list: imap_folders) }
+  let(:imap_folders) { [] }
+
+  before do
+    allow(Net::IMAP).to receive(:new) { imap }
+  end
+
+  describe "#list" do
+    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.list).to eq(["Gelöscht"])
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 describe Imap::Backup::Configuration::ConnectionTester do
   describe ".test" do
     let(:connection) do
-      instance_double(Imap::Backup::Account::Connection, imap: nil)
+      instance_double(Imap::Backup::Account::Connection, client: nil)
     end
 
     before do
@@ -10,7 +10,7 @@ describe Imap::Backup::Configuration::ConnectionTester do
 
     describe "call" do
       it "tries to connect" do
-        expect(connection).to receive(:imap)
+        expect(connection).to receive(:client)
 
         subject.test("foo")
       end
@@ -24,7 +24,7 @@ describe Imap::Backup::Configuration::ConnectionTester do
 
     describe "failure" do
       before do
-        allow(connection).to receive(:imap).and_raise(error)
+        allow(connection).to receive(:client).and_raise(error)
       end
 
       context "with no connection" do