imap-backup 2.0.0 → 2.2.2

data/spec/unit/imap/backup/serializer/mbox_enumerator_spec.rb

@@ -0,0 +1,45 @@
+require "imap/backup/serializer/mbox_enumerator"
+
+describe Imap::Backup::Serializer::MboxEnumerator do
+  subject { described_class.new(mbox_pathname) }
+
+  let(:mbox_pathname) { "/mbox/pathname" }
+  let(:mbox_file) { instance_double(File) }
+  let(:lines) { message1 + message2 + [nil] }
+  let(:message1) do
+    [
+      "From Frida\r\n",
+      "Hello\r\n"
+    ]
+  end
+  let(:message2) do
+    [
+      "From John\r\n",
+      "Hi\r\n"
+    ]
+  end
+
+  before do
+    allow(File).to receive(:open).and_call_original
+    allow(File).to receive(:open).with(mbox_pathname, "rb").and_yield(mbox_file)
+    allow(mbox_file).to receive(:gets).and_return(*lines)
+  end
+
+  describe "#each" do
+    it "reads files as binary" do
+      expect(File).to receive(:open).with(mbox_pathname, "rb")
+      subject.each {}
+    end
+
+    it "yields messages" do
+      expect { |b| subject.each(&b) }.
+        to yield_successive_args(message1.join, message2.join)
+    end
+
+    context "without a block" do
+      it "returns an Enumerator" do
+        expect(subject.each).to be_a(Enumerator)
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/serializer/mbox_spec.rb

@@ -1,4 +1,6 @@
 describe Imap::Backup::Serializer::Mbox do
+  subject { described_class.new(base_path, imap_folder) }
+
   let(:base_path) { "/base/path" }
   let(:store) do
     instance_double(
@@ -7,7 +9,8 @@ describe Imap::Backup::Serializer::Mbox do
       rename: nil,
       uids: nil,
       uid_validity: existing_uid_validity,
-      "uid_validity=": nil
+      "uid_validity=": nil,
+      update_uid: nil
     )
   end
   let(:imap_folder) { "folder" }
@@ -20,103 +23,91 @@ describe Imap::Backup::Serializer::Mbox do
     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
-
-  subject { described_class.new(base_path, imap_folder) }
-
-  before do
     allow(FileUtils).to receive(:chmod)
     allow(Imap::Backup::Serializer::MboxStore).to receive(:new) { store }
   end
 
-  context "containing directory" do
-    before { subject.uids }
-
-    context "when the IMAP folder has multiple elements" do
+  describe "folder path" do
+    context "when it has multiple elements" do
       let(:imap_folder) { "folder/path" }
 
       context "when the containing directory is missing" do
         let(:dir_exists) { false }
 
         it "is created" do
-          expect(Imap::Backup::Utils).to have_received(:make_folder).
+          expect(Imap::Backup::Utils).to receive(:make_folder).
             with(base_path, File.dirname(imap_folder), 0o700)
+
+          subject.uids
         end
       end
     end
 
-    context "when the containing directory permissons are incorrect" do
+    context "when permissions are incorrect" do
       let(:permissions) { 0o777 }
 
       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)
+        expect(FileUtils).to receive(:chmod).with(0o700, path)
+
+        subject.uids
       end
     end
 
-    context "when the containing directory permissons are correct" do
+    context "when permissons are correct" do
       it "does nothing" do
-        expect(FileUtils).to_not have_received(:chmod)
+        expect(FileUtils).to_not receive(:chmod)
+
+        subject.uids
       end
     end
 
-    context "when the containing directory exists" do
+    context "when it exists" do
       it "is not created" do
-        expect(Imap::Backup::Utils).to_not have_received(:make_folder).
+        expect(Imap::Backup::Utils).to_not receive(:make_folder).
           with(base_path, File.dirname(imap_folder), 0o700)
-      end
-    end
-  end
-
-  context "#uids" do
-    it "calls the store" do
-      subject.uids
-
-      expect(store).to have_received(:uids)
-    end
-  end
-
-  context "#save" do
-    it "calls the store" do
-      subject.save("foo", "bar")
 
-      expect(store).to have_received(:add)
+        subject.uids
+      end
     end
   end
 
-  context "#set_uid_validity" do
-    let(:result) { subject.set_uid_validity("aaa") }
-
+  describe "#apply_uid_validity" do
     context "when the existing uid validity is unset" do
-      let!(:result) { super() }
-
       it "sets uid validity" do
-        expect(store).to have_received(:uid_validity=).with("aaa")
+        expect(store).to receive(:uid_validity=).with("aaa")
+
+        subject.apply_uid_validity("aaa")
       end
 
       it "does not rename the store" do
-        expect(store).to_not have_received(:rename)
+        expect(store).to_not receive(:rename)
+
+        subject.apply_uid_validity("aaa")
       end
 
       it "returns nil" do
-        expect(result).to be_nil
+        expect(subject.apply_uid_validity("aaa")).to be_nil
       end
     end
 
     context "when the uid validity is unchanged" do
-      let!(:result) { super() }
       let(:existing_uid_validity) { "aaa" }
 
       it "does not set uid validity" do
-        expect(store).to_not have_received(:uid_validity=)
+        expect(store).to_not receive(:uid_validity=)
+
+        subject.apply_uid_validity("aaa")
       end
 
       it "does not rename the store" do
-        expect(store).to_not have_received(:rename)
+        expect(store).to_not receive(:rename)
+
+        subject.apply_uid_validity("aaa")
       end
 
       it "returns nil" do
-        expect(result).to be_nil
+        expect(subject.apply_uid_validity("aaa")).to be_nil
       end
     end
 
@@ -131,20 +122,23 @@ describe Imap::Backup::Serializer::Mbox do
         allow(Imap::Backup::Serializer::MboxStore).
           to receive(:new).with(anything, /bbb/) { existing_store }
         allow(existing_store).to receive(:exist?).and_return(exists, false)
-        result
       end
 
       it "sets uid validity" do
-        expect(store).to have_received(:uid_validity=).with("aaa")
+        expect(store).to receive(:uid_validity=).with("aaa")
+
+        subject.apply_uid_validity("aaa")
       end
 
       context "when adding the uid validity does not cause a name clash" do
         it "renames the store, adding the existing uid validity" do
-          expect(store).to have_received(:rename).with("folder.bbb")
+          expect(store).to receive(:rename).with("folder.bbb")
+
+          subject.apply_uid_validity("aaa")
         end
 
         it "returns the new name" do
-          expect(result).to eq("folder.bbb")
+          expect(subject.apply_uid_validity("aaa")).to eq("folder.bbb")
         end
       end
 
@@ -152,13 +146,77 @@ describe Imap::Backup::Serializer::Mbox do
         let(:exists) { true }
 
         it "renames the store, adding the existing uid validity and a digit" do
-          expect(store).to have_received(:rename).with("folder.bbb.1")
+          expect(store).to receive(:rename).with("folder.bbb.1")
+
+          subject.apply_uid_validity("aaa")
         end
 
         it "returns the new name" do
-          expect(result).to eq("folder.bbb.1")
+          expect(subject.apply_uid_validity("aaa")).to eq("folder.bbb.1")
         end
       end
     end
   end
+
+  describe "#force_uid_validity" do
+    it "sets the uid_validity" do
+      expect(store).to receive(:uid_validity=).with("66")
+
+      subject.force_uid_validity("66")
+    end
+  end
+
+  describe "#uids" do
+    it "calls the store" do
+      expect(store).to receive(:uids)
+
+      subject.uids
+    end
+  end
+
+  describe "#load" do
+    before { allow(store).to receive(:load).with("66") { "xxx" } }
+
+    it "returns the value loaded by the store" do
+      expect(subject.load("66")).to eq("xxx")
+    end
+  end
+
+  describe "#each_message" do
+    it "calls the store" do
+      expect(store).to receive(:each_message).with([1])
+
+      subject.each_message([1])
+    end
+  end
+
+  describe "#save" do
+    it "calls the store" do
+      expect(store).to receive(:add).with("foo", "bar")
+
+      subject.save("foo", "bar")
+    end
+  end
+
+  describe "#rename" do
+    it "calls the store" do
+      expect(store).to receive(:rename).with("foo")
+
+      subject.rename("foo")
+    end
+
+    it "updates the folder name" do
+      subject.rename("foo")
+
+      expect(subject.folder).to eq("foo")
+    end
+  end
+
+  describe "#update_uid" do
+    it "calls the store" do
+      expect(store).to receive(:update_uid).with("foo", "bar")
+
+      subject.update_uid("foo", "bar")
+    end
+  end
 end

data/spec/unit/imap/backup/serializer/mbox_store_spec.rb

@@ -1,23 +1,24 @@
 describe Imap::Backup::Serializer::MboxStore do
+  subject { described_class.new(base_path, folder) }
+
   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_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(:imap_file) { instance_double(File, 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(:mbox_file) { instance_double(File, 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
+      uid_validity: uid_validity,
+      uids: uids
     }.to_json
   end
-
-  subject { described_class.new(base_path, folder) }
+  let(:uid_validity) { 123 }
 
   before do
     allow(File).to receive(:exist?).and_call_original
@@ -40,9 +41,32 @@ describe Imap::Backup::Serializer::MboxStore do
     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)
+  describe "#uid_validity=" do
+    let(:new_uid_validity) { "13" }
+    let(:updated_imap_content) do
+      {
+        version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
+        uid_validity: new_uid_validity,
+        uids: uids
+      }.to_json
+    end
+
+    it "sets uid_validity" do
+      subject.uid_validity = new_uid_validity
+
+      expect(subject.uid_validity).to eq(new_uid_validity)
+    end
+
+    it "writes the imap file" do
+      expect(imap_file).to receive(:write).with(updated_imap_content)
+
+      subject.uid_validity = new_uid_validity
+    end
+  end
+
+  describe "#uids" do
+    it "returns the backed-up uids as integers" do
+      expect(subject.uids).to eq(uids.map(&:to_i))
     end
 
     context "when the imap file does not exist" do
@@ -53,6 +77,34 @@ describe Imap::Backup::Serializer::MboxStore do
       end
     end
 
+    context "when the imap file is malformed" do
+      before do
+        allow(JSON).to receive(:parse).and_raise(JSON::ParserError)
+      end
+
+      it "returns an empty Array" do
+        expect(subject.uids).to eq([])
+      end
+
+      it "deletes the imap file" do
+        expect(File).to receive(:unlink).with(imap_pathname)
+
+        subject.uids
+      end
+
+      it "deletes the mbox file" do
+        expect(File).to receive(:unlink).with(mbox_pathname)
+
+        subject.uids
+      end
+
+      it "writes a blank mbox file" do
+        expect(mbox_file).to receive(:write).with("")
+
+        subject.uids
+      end
+    end
+
     context "when the mbox does not exist" do
       let(:mbox_exists) { false }
 
@@ -62,7 +114,7 @@ describe Imap::Backup::Serializer::MboxStore do
     end
   end
 
-  context "#add" do
+  describe "#add" do
     let(:mbox_formatted_message) { "message in mbox format" }
     let(:message_uid) { "999" }
     let(:message) do
@@ -74,27 +126,36 @@ describe Imap::Backup::Serializer::MboxStore do
     let(:updated_imap_content) do
       {
         version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
-        uid_validity: 123,
-        uids: (uids + [999]).sort
+        uid_validity: uid_validity,
+        uids: uids + [999]
       }.to_json
     end
 
     before do
-      allow(Email::Mboxrd::Message).to receive(:new).and_return(message)
+      allow(Email::Mboxrd::Message).to receive(:new) { 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 receive(:write).with(mbox_formatted_message)
 
-      expect(mbox_file).to have_received(:write).with(mbox_formatted_message)
+      subject.add(message_uid, "The\nemail\n")
     end
 
     it "saves the uid to the imap file" do
+      expect(imap_file).to receive(:write).with(updated_imap_content)
+
       subject.add(message_uid, "The\nemail\n")
+    end
+
+    context "when the message is already downloaded" do
+      let(:uids) { [999] }
 
-      expect(imap_file).to have_received(:write).with(updated_imap_content)
+      it "skips the message" do
+        expect(mbox_file).to_not receive(:write)
+
+        subject.add(message_uid, "The\nemail\n")
+      end
     end
 
     context "when the message causes parsing errors" do
@@ -103,8 +164,9 @@ describe Imap::Backup::Serializer::MboxStore do
       end
 
       it "skips the message" do
+        expect(mbox_file).to_not receive(:write)
+
         subject.add(message_uid, "The\nemail\n")
-        expect(mbox_file).to_not have_received(:write)
       end
 
       it "does not fail" do
@@ -114,4 +176,154 @@ describe Imap::Backup::Serializer::MboxStore do
       end
     end
   end
+
+  describe "#load" do
+    let(:uid) { "1" }
+    let(:enumerator) do
+      instance_double(Imap::Backup::Serializer::MboxEnumerator)
+    end
+    let(:enumeration) { instance_double(Enumerator) }
+
+    before do
+      allow(Imap::Backup::Serializer::MboxEnumerator).
+        to receive(:new) { enumerator }
+      allow(enumerator).to receive(:each) { enumeration }
+      allow(enumeration).
+        to receive(:with_index).
+        and_yield("", 0).
+        and_yield("", 1).
+        and_yield("ciao", 2)
+    end
+
+    it "returns the message" do
+      expect(subject.load(uid).supplied_body).to eq("ciao")
+    end
+
+    context "when the UID is unknown" do
+      let(:uid) { "99" }
+
+      it "returns nil" do
+        expect(subject.load(uid)).to be_nil
+      end
+    end
+  end
+
+  describe "#each_message" do
+    let(:enumerator) do
+      instance_double(Imap::Backup::Serializer::MboxEnumerator)
+    end
+    let(:enumeration) { instance_double(Enumerator) }
+
+    before do
+      allow(Imap::Backup::Serializer::MboxEnumerator).
+        to receive(:new) { enumerator }
+      allow(enumerator).to receive(:each) { enumeration }
+      allow(enumeration).
+        to receive(:with_index).
+        and_yield("", 0).
+        and_yield("", 1).
+        and_yield("ciao", 2)
+    end
+
+    it "yields messages" do
+      expect { |b| subject.each_message([1], &b) }.
+        to yield_successive_args([1, instance_of(Email::Mboxrd::Message)])
+    end
+
+    it "yields the requested message uid" do
+      subject.each_message([1]) do |uid, _message|
+        expect(uid).to eq(1)
+      end
+    end
+
+    it "yields the requested message" do
+      subject.each_message([1]) do |_uid, message|
+        expect(message.supplied_body).to eq("ciao")
+      end
+    end
+
+    context "without a block" do
+      it "returns an Enumerator" do
+        expect(subject.each_message([1])).to be_a(Enumerator)
+      end
+    end
+  end
+
+  describe "#update_uid" do
+    let(:old_uid) { "2" }
+    let(:updated_imap_content) do
+      {
+        version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
+        uid_validity: uid_validity,
+        uids: [3, 999, 1]
+      }.to_json
+    end
+
+    it "updates the stored UID" do
+      expect(imap_file).to receive(:write).with(updated_imap_content)
+
+      subject.update_uid(old_uid, "999")
+    end
+
+    context "when the UID is unknown" do
+      let(:old_uid) { "42" }
+
+      it "does nothing" do
+        expect(imap_file).to_not receive(:write)
+
+        subject.update_uid(old_uid, "999")
+      end
+    end
+  end
+
+  describe "#reset" do
+    it "deletes the imap file" do
+      expect(File).to receive(:unlink).with(imap_pathname)
+
+      subject.reset
+    end
+
+    it "deletes the mbox file" do
+      expect(File).to receive(:unlink).with(mbox_pathname)
+
+      subject.reset
+    end
+
+    it "writes a blank mbox file" do
+      expect(mbox_file).to receive(:write).with("")
+
+      subject.reset
+    end
+  end
+
+  describe "#rename" do
+    let(:new_name) { "new_name" }
+    let(:new_folder_path) { File.join(base_path, new_name) }
+    let(:new_imap_name) { "#{new_folder_path}.imap" }
+    let(:new_mbox_name) { "#{new_folder_path}.mbox" }
+
+    before do
+      allow(File).to receive(:rename).and_call_original
+      allow(File).to receive(:rename).with(imap_pathname, new_imap_name)
+      allow(File).to receive(:rename).with(mbox_pathname, new_mbox_name)
+    end
+
+    it "renames the imap file" do
+      expect(File).to receive(:rename).with(imap_pathname, new_imap_name)
+
+      subject.rename(new_name)
+    end
+
+    it "renames the mbox file" do
+      expect(File).to receive(:rename).with(mbox_pathname, new_mbox_name)
+
+      subject.rename(new_name)
+    end
+
+    it "updates the folder name" do
+      subject.rename(new_name)
+
+      expect(subject.folder).to eq(new_name)
+    end
+  end
 end