imap-backup 1.4.2 → 2.0.0.rc1

data/spec/features/support/backup_directory.rb

@@ -3,7 +3,7 @@ module BackupDirectoryHelpers
     from = fixture("connection")[:username]
     subject = options[:subject]
     body = options[:body]
-    body_and_headers = <<-EOT.gsub("\n", "\r\n")
+    body_and_headers = <<-EOT
 From: #{from}
 Subject: #{subject}
 
@@ -13,6 +13,14 @@ Subject: #{subject}
     "From #{from}\n#{body_and_headers}\n"
   end
 
+  def imap_data(uid_validity, uids)
+    {
+      version: 2,
+      uid_validity: uid_validity,
+      uids: uids
+    }
+  end
+
   def mbox_content(name)
     File.read(mbox_path(name))
   end
@@ -20,6 +28,18 @@ Subject: #{subject}
   def mbox_path(name)
     File.join(local_backup_path, name + ".mbox")
   end
+
+  def imap_path(name)
+    File.join(local_backup_path, name + ".imap")
+  end
+
+  def imap_content(name)
+    File.read(imap_path(name))
+  end
+
+  def imap_parsed(name)
+    JSON.parse(imap_content(name), symbolize_names: true)
+  end
 end
 
 RSpec.configure do |config|

data/spec/features/support/email_server.rb

@@ -1,18 +1,43 @@
 module EmailServerHelpers
   REQUESTED_ATTRIBUTES = ["RFC822", "FLAGS", "INTERNALDATE"]
+  DEFAULT_EMAIL = "address@example.org"
 
   def send_email(folder, options)
-    from = options[:from] || "address@example.org"
+    message = message_as_server_message(options)
+    imap.append(folder, message, nil, nil)
+  end
+
+  def message_as_server_message(options)
+    from = options[:from] || DEFAULT_EMAIL
     subject = options[:subject]
     body = options[:body]
-    message = <<-EOT
+    message = <<-EOT.gsub("\n", "\r\n")
 From: #{from}
 Subject: #{subject}
 
 #{body}
+
     EOT
+  end
 
-    imap.append(folder, message, nil, nil)
+  def server_messages(folder)
+    server_uids(folder).map do |uid|
+      server_fetch_email(folder, uid)
+    end
+  end
+
+  def server_message_to_body(message)
+    message["RFC822"]
+  end
+
+  def server_fetch_email(folder, uid)
+    examine folder
+    fetch_data_items = imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)
+    return nil if fetch_data_items.nil?
+    fetch_data_item = fetch_data_items[0]
+    attributes = fetch_data_item.attr
+    attributes["RFC822"].force_encoding("utf-8")
+    attributes
   end
 
   def delete_emails(folder)
@@ -22,6 +47,44 @@ Subject: #{subject}
     imap.expunge
   end
 
+  def examine(folder)
+    imap.examine(folder)
+  end
+
+  def server_uids(folder)
+    examine(folder)
+    imap.uid_search(["ALL"]).sort
+  end
+
+  def server_uid_validity(folder)
+    examine(folder)
+    imap.responses["UIDVALIDITY"][0]
+  end
+
+  def server_folders
+    root_info = imap.list("", "")[0]
+    root = root_info.name
+    imap.list(root, "*")
+  end
+
+  def server_create_folder(folder)
+    imap.create(folder)
+    imap.disconnect
+    @imap = nil
+  end
+
+  def server_rename_folder(from, to)
+    imap.rename(from, to)
+    imap.disconnect
+    @imap = nil
+  end
+
+  def server_delete_folder(folder)
+    imap.delete folder
+    imap.disconnect
+    @imap = nil
+  end
+
   def imap
     @imap ||=
       begin

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

@@ -1,6 +1,8 @@
 shared_context "message-fixtures" do
   let(:uid1) { 123 }
   let(:uid2) { 345 }
+  let(:uid3) { 567 }
   let(:msg1) { {uid: uid1, subject: "Test 1", body: "body 1\nHi"} }
   let(:msg2) { {uid: uid2, subject: "Test 2", body: "body 2"} }
+  let(:msg3) { {uid: uid3, subject: "Test 3", body: "body 3"} }
 end

data/spec/fixtures/connection.yml

@@ -2,6 +2,5 @@
 :username: 'address@example.org'
 :password: 'pass'
 :connection_options:
-  :port: 8993
-  :ssl:
-    :verify_mode: 0
+  :port: 8143
+  :ssl: false

data/spec/unit/account/connection_spec.rb

@@ -10,7 +10,7 @@ describe Imap::Backup::Account::Connection do
   end
 
   let(:imap) do
-    double("Net::IMAP", login: nil, disconnect: nil)
+    instance_double(Net::IMAP, login: nil, disconnect: nil)
   end
   let(:imap_folders) { [] }
   let(:options) do
@@ -86,7 +86,9 @@ describe Imap::Backup::Account::Connection do
   end
 
   context "#status" do
-    let(:folder) { double("folder", uids: [remote_uid]) }
+    let(:folder) do
+      instance_double(Imap::Backup::Account::Folder, uids: [remote_uid])
+    end
     let(:local_uid) { "local_uid" }
     let(:serializer) do
       instance_double(Imap::Backup::Serializer::Mbox, uids: [local_uid])
@@ -112,9 +114,21 @@ describe Imap::Backup::Account::Connection do
   end
 
   context "#run_backup" do
-    let(:folder) { double("folder", name: "folder") }
-    let(:serializer) { double("serializer") }
-    let(:downloader) { double(Imap::Backup::Downloader, run: nil) }
+    let(:folder) do
+      instance_double(
+        Imap::Backup::Account::Folder,
+        name: "folder",
+        uid_validity: uid_validity
+      )
+    end
+    let(:uid_validity) { 123 }
+    let(:serializer) do
+      instance_double(
+        Imap::Backup::Serializer::Mbox,
+        set_uid_validity: nil
+      )
+    end
+    let(:downloader) { instance_double(Imap::Backup::Downloader, run: nil) }
 
     before do
       allow(Imap::Backup::Downloader).

data/spec/unit/configuration/account_spec.rb

@@ -143,7 +143,8 @@ describe Imap::Backup::Configuration::Account do
       context "if the server is blank" do
         [
           ["GMail", "foo@gmail.com", "imap.gmail.com"],
-          ["Fastmail", "bar@fastmail.fm", "mail.messagingengine.com"]
+          ["Fastmail", "bar@fastmail.fm", "imap.fastmail.com"],
+          ["Fastmail", "bar@fastmail.com", "imap.fastmail.com"]
         ].each do |service, email, expected|
           context service do
             let(:new_email) { email }

data/spec/unit/email/provider_spec.rb

@@ -26,11 +26,7 @@ describe Email::Provider 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)
+      expect(subject.options).to eq(port: 993, ssl: true)
     end
   end
 

data/spec/unit/serializer/mbox_spec.rb

@@ -1,119 +1,82 @@
-require "spec_helper"
-
 describe Imap::Backup::Serializer::Mbox do
-  let(:stat) { double("File::Stat", mode: 0o700) }
   let(:base_path) { "/base/path" }
-  let(:mbox_pathname) { "/base/path/my/folder.mbox" }
-  let(:mbox_exists) { true }
-  let(:imap_pathname) { "/base/path/my/folder.imap" }
-  let(:imap_exists) { true }
+  let(:store) do
+    instance_double(
+      Imap::Backup::Serializer::MboxStore,
+      add: nil,
+      uids: nil
+    )
+  end
+  let(:imap_folder) { "folder" }
+  let(:permissions) { 0o700 }
+  let(:dir_exists) { true }
 
   before do
     allow(Imap::Backup::Utils).to receive(:make_folder)
-    allow(File).to receive(:exist?).with(base_path).and_return(true)
-    allow(File).to receive(:stat).with(base_path).and_return(stat)
-    allow(File).to receive(:exist?).with(mbox_pathname).and_return(mbox_exists)
-    allow(File).to receive(:exist?).with(imap_pathname).and_return(imap_exists)
+    allow(Imap::Backup::Utils).to receive(:mode) { permissions }
+    allow(Imap::Backup::Utils).to receive(:check_permissions) { true }
+    allow(File).to receive(:directory?) { dir_exists }
   end
 
-  context "#initialize" do
-    it "creates the containing directory" do
-      described_class.new(base_path, "my/folder")
+  subject { described_class.new(base_path, imap_folder) }
 
-      expect(Imap::Backup::Utils).
-        to have_received(:make_folder).with(base_path, "my", 0o700)
-    end
+  before do
+    allow(FileUtils).to receive(:chmod)
+    allow(Imap::Backup::Serializer::MboxStore).to receive(:new) { store }
+  end
 
-    context "mbox and imap files" do
-      context "if mbox exists and imap doesn't" do
-        let(:imap_exists) { false }
+  context "containing directory" do
+    before { subject.uids }
 
-        it "fails" do
-          expect {
-            described_class.new(base_path, "my/folder")
-          }.to raise_error(RuntimeError, ".imap file missing")
-        end
-      end
+    context "when the IMAP folder has multiple elements" do
+      let(:imap_folder) { "folder/path" }
 
-      context "if imap exists and mbox doesn't" do
-        let(:mbox_exists) { false }
+      context "when the containing directory is missing" do
+        let(:dir_exists) { false }
 
-        it "fails" do
-          expect {
-            described_class.new(base_path, "my/folder")
-          }.to raise_error(RuntimeError, ".mbox file missing")
+        it "is created" do
+          expect(Imap::Backup::Utils).to have_received(:make_folder).
+            with(base_path, File.dirname(imap_folder), 0o700)
         end
       end
     end
-  end
 
-  context "instance methods" do
-    let(:ids) { %w(3 2 1) }
+    context "when the containing directory permissons are incorrect" do
+      let(:permissions) { 0o777 }
 
-    before do
-      allow(CSV).to receive(:foreach) { |&b| ids.each { |id| b.call [id] } }
-    end
-
-    subject { described_class.new(base_path, "my/folder") }
-
-    context "#uids" do
-      it "returns the backed-up uids as sorted integers" do
-        expect(subject.uids).to eq(ids.map(&:to_i).sort)
-      end
-
-      context "if the mbox does not exist" do
-        let(:mbox_exists) { false }
-        let(:imap_exists) { false }
-
-        it "returns an empty Array" do
-          expect(subject.uids).to eq([])
-        end
+      it "corrects them" do
+        path = File.expand_path(File.join(base_path, File.dirname(imap_folder)))
+        expect(FileUtils).to have_received(:chmod).with(0o700, path)
       end
     end
 
-    context "#save" do
-      let(:mbox_formatted_message) { "message in mbox format" }
-      let(:message_uid) { "999" }
-      let(:message) do
-        double("Email::Mboxrd::Message", to_serialized: mbox_formatted_message)
+    context "when the containing directory permissons are correct" do
+      it "does nothing" do
+        expect(FileUtils).to_not have_received(:chmod)
       end
-      let(:mbox_file) { double("File - mbox", write: nil, close: nil) }
-      let(:imap_file) { double("File - imap", write: nil, close: nil) }
-
-      before do
-        allow(Email::Mboxrd::Message).to receive(:new).and_return(message)
-        allow(File).to receive(:open).with(mbox_pathname, "ab") { mbox_file }
-        allow(File).to receive(:open).with(imap_pathname, "ab") { imap_file }
-      end
-
-      it "saves the message to the mbox" do
-        subject.save(message_uid, "The\nemail\n")
+    end
 
-        expect(mbox_file).to have_received(:write).with(mbox_formatted_message)
+    context "when the containing directory exists" do
+      it "is not created" do
+        expect(Imap::Backup::Utils).to_not have_received(:make_folder).
+          with(base_path, File.dirname(imap_folder), 0o700)
       end
+    end
+  end
 
-      it "saves the uid to the imap file" do
-        subject.save(message_uid, "The\nemail\n")
-
-        expect(imap_file).to have_received(:write).with(message_uid + "\n")
-      end
+  context "#uids" do
+    it "calls the store" do
+      subject.uids
 
-      context "when the message causes parsing errors" do
-        before do
-          allow(message).to receive(:to_serialized).and_raise(ArgumentError)
-        end
+      expect(store).to have_received(:uids)
+    end
+  end
 
-        it "skips the message" do
-          subject.save(message_uid, "The\nemail\n")
-          expect(mbox_file).to_not have_received(:write)
-        end
+  context "#save" do
+    it "calls the store" do
+      subject.save("foo", "bar")
 
-        it "does not fail" do
-          expect do
-            subject.save(message_uid, "The\nemail\n")
-          end.to_not raise_error
-        end
-      end
+      expect(store).to have_received(:add)
     end
   end
 end

data/spec/unit/serializer/mbox_store_spec.rb

@@ -0,0 +1,117 @@
+describe Imap::Backup::Serializer::MboxStore do
+  let(:base_path) { "/base/path" }
+  let(:folder) { "the/folder" }
+  let(:folder_path) { File.join(base_path, folder) }
+  let(:imap_pathname) { folder_path + ".imap" }
+  let(:imap_exists) { true }
+  let(:imap_file) { double("File - imap", write: nil, close: nil) }
+  let(:mbox_pathname) { folder_path + ".mbox" }
+  let(:mbox_exists) { true }
+  let(:mbox_file) { double("File - mbox", write: nil, close: nil) }
+  let(:uids) { [3, 2, 1] }
+  let(:imap_content) do
+    {
+      version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
+      uid_validity: 123,
+      uids: uids.sort
+    }.to_json
+  end
+
+  subject { described_class.new(base_path, folder) }
+
+  before do
+    allow(File).to receive(:exist?).and_call_original
+    allow(File).to receive(:exist?).with(imap_pathname) { imap_exists }
+    allow(File).to receive(:exist?).with(mbox_pathname) { mbox_exists }
+
+    allow(File).to receive(:open).and_call_original
+    allow(File).
+      to receive(:open).with("/base/path/my/folder.imap") { imap_content }
+    allow(File).to receive(:open).with(imap_pathname, "w").and_yield(imap_file)
+    allow(File).to receive(:open).with(mbox_pathname, "w").and_yield(mbox_file)
+
+    allow(File).to receive(:read).and_call_original
+    allow(File).to receive(:read).with(imap_pathname) { imap_content }
+
+    allow(File).to receive(:unlink).and_call_original
+    allow(File).to receive(:unlink).with(imap_pathname)
+    allow(File).to receive(:unlink).with(mbox_pathname)
+
+    allow(FileUtils).to receive(:chmod)
+  end
+
+  context "#uids" do
+    it "returns the backed-up uids as sorted integers" do
+      expect(subject.uids).to eq(uids.map(&:to_i).sort)
+    end
+
+    context "when the imap file does not exist" do
+      let(:imap_exists) { false }
+
+      it "returns an empty Array" do
+        expect(subject.uids).to eq([])
+      end
+    end
+
+    context "when the mbox does not exist" do
+      let(:mbox_exists) { false }
+
+      it "returns an empty Array" do
+        expect(subject.uids).to eq([])
+      end
+    end
+  end
+
+  context "#add" do
+    let(:mbox_formatted_message) { "message in mbox format" }
+    let(:message_uid) { "999" }
+    let(:message) do
+      instance_double(
+        Email::Mboxrd::Message,
+        to_serialized: mbox_formatted_message
+      )
+    end
+    let(:updated_imap_content) do
+      {
+        version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
+        uid_validity: 123,
+        uids: (uids + [999]).sort
+      }.to_json
+    end
+
+    before do
+      allow(Email::Mboxrd::Message).to receive(:new).and_return(message)
+      allow(File).to receive(:open).with(mbox_pathname, "ab") { mbox_file }
+      subject.uid_validity = 123
+    end
+
+    it "saves the message to the mbox" do
+      subject.add(message_uid, "The\nemail\n")
+
+      expect(mbox_file).to have_received(:write).with(mbox_formatted_message)
+    end
+
+    it "saves the uid to the imap file" do
+      subject.add(message_uid, "The\nemail\n")
+
+      expect(imap_file).to have_received(:write).with(updated_imap_content)
+    end
+
+    context "when the message causes parsing errors" do
+      before do
+        allow(message).to receive(:to_serialized).and_raise(ArgumentError)
+      end
+
+      it "skips the message" do
+        subject.add(message_uid, "The\nemail\n")
+        expect(mbox_file).to_not have_received(:write)
+      end
+
+      it "does not fail" do
+        expect do
+          subject.add(message_uid, "The\nemail\n")
+        end.to_not raise_error
+      end
+    end
+  end
+end