imap-backup 5.2.0 → 6.0.0.rc2

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

@@ -1,222 +1,101 @@
-describe Imap::Backup::Serializer::Mbox do
-  subject { described_class.new(base_path, imap_folder) }
-
-  let(:base_path) { "/base/path" }
-  let(:store) do
-    instance_double(
-      Imap::Backup::Serializer::MboxStore,
-      add: nil,
-      rename: nil,
-      uids: nil,
-      uid_validity: existing_uid_validity,
-      "uid_validity=": nil,
-      update_uid: nil
-    )
-  end
-  let(:imap_folder) { "folder" }
-  let(:permissions) { 0o700 }
-  let(:dir_exists) { true }
-  let(:existing_uid_validity) { nil }
-
-  before do
-    allow(Imap::Backup::Utils).to receive(:make_folder)
-    allow(Imap::Backup::Utils).to receive(:mode) { permissions }
-    allow(Imap::Backup::Utils).to receive(:check_permissions) { true }
-    allow(File).to receive(:directory?) { dir_exists }
-    allow(FileUtils).to receive(:chmod)
-    allow(Imap::Backup::Serializer::MboxStore).to receive(:new) { store }
-  end
-
-  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 receive(:make_folder).
-            with(base_path, File.dirname(imap_folder), 0o700)
-
-          subject.uids
-        end
-      end
+module Imap::Backup
+  describe Serializer::Mbox do
+    subject { described_class.new(folder_path) }
+
+    let(:folder_path) { "folder_path" }
+    let(:pathname) { "folder_path.mbox" }
+    let(:exists) { true }
+    let(:file) { instance_double(File, truncate: nil, write: nil) }
+
+    before do
+      allow(File).to receive(:exist?).and_call_original
+      allow(File).to receive(:exist?).with(pathname) { exists }
+      allow(File).to receive(:open).with(pathname, "ab").and_yield(file)
+      allow(File).to receive(:read).with(pathname) { existing.to_json }
     end
 
-    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 receive(:chmod).with(0o700, path)
+    describe "#append" do
+      it "appends the message" do
+        subject.append("message")
 
-        subject.uids
+        expect(file).to have_received(:write).with("message")
       end
     end
 
-    context "when permissons are correct" do
-      it "does nothing" do
-        expect(FileUtils).to_not receive(:chmod)
-
-        subject.uids
+    describe "#exist?" do
+      context "when the mailbox exists" do
+        it "is true" do
+          expect(subject.exist?).to be true
+        end
       end
-    end
 
-    context "when it exists" do
-      it "is not created" do
-        expect(Imap::Backup::Utils).to_not receive(:make_folder).
-          with(base_path, File.dirname(imap_folder), 0o700)
+      context "when the mailbox doesn't exist" do
+        let(:exists) { false }
 
-        subject.uids
+        it "is false" do
+          expect(subject.exist?).to be false
+        end
       end
     end
-  end
-
-  describe "#apply_uid_validity" do
-    context "when the existing uid validity is unset" do
-      it "sets uid validity" do
-        expect(store).to receive(:uid_validity=).with("aaa")
 
-        subject.apply_uid_validity("aaa")
-      end
+    describe "#length" do
+      let(:stat) { instance_double(File::Stat, size: 99) }
 
-      it "does not rename the store" do
-        expect(store).to_not receive(:rename)
+      before { allow(File).to receive(:stat) { stat } }
 
-        subject.apply_uid_validity("aaa")
-      end
-
-      it "returns nil" do
-        expect(subject.apply_uid_validity("aaa")).to be_nil
+      it "returns the length of the mailbox file" do
+        expect(subject.length).to eq(99)
       end
     end
 
-    context "when the uid validity is unchanged" do
-      let(:existing_uid_validity) { "aaa" }
-
-      it "does not set uid validity" do
-        expect(store).to_not receive(:uid_validity=)
-
-        subject.apply_uid_validity("aaa")
-      end
-
-      it "does not rename the store" do
-        expect(store).to_not receive(:rename)
-
-        subject.apply_uid_validity("aaa")
-      end
-
-      it "returns nil" do
-        expect(subject.apply_uid_validity("aaa")).to be_nil
+    describe "#pathname" do
+      it "is the folder_path plus .mbox" do
+        expect(subject.pathname).to eq("folder_path.mbox")
       end
     end
 
-    context "when the uid validity is changed" do
-      let(:existing_uid_validity) { "bbb" }
-      let(:existing_store) do
-        instance_double(Imap::Backup::Serializer::MboxStore)
-      end
-      let(:exists) { false }
-
-      before do
-        allow(Imap::Backup::Serializer::MboxStore).
-          to receive(:new).with(anything, /bbb/) { existing_store }
-        allow(existing_store).to receive(:exist?).and_return(exists, false)
-      end
-
-      it "sets uid validity" do
-        expect(store).to receive(:uid_validity=).with("aaa")
+    describe "#rename" do
+      context "when the mailbox exists" do
+        let(:exists) { true }
 
-        subject.apply_uid_validity("aaa")
-      end
+        before do
+          allow(File).to receive(:rename)
 
-      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 receive(:rename).with("folder-bbb")
+          subject.rename("new_name")
+        end
 
-          subject.apply_uid_validity("aaa")
+        it "renames the mailbox" do
+          expect(File).to have_received(:rename)
         end
 
-        it "returns the new name" do
-          expect(subject.apply_uid_validity("aaa")).to eq("folder-bbb")
+        it "sets the folder_path" do
+          expect(subject.folder_path).to eq("new_name")
         end
       end
 
-      context "when adding the uid validity causes a name clash" do
-        let(:exists) { true }
-
-        it "renames the store, adding the existing uid validity and a digit" do
-          expect(store).to receive(:rename).with("folder-bbb-1")
+      context "when the mailbox doesn't exist" do
+        let(:exists) { false }
 
-          subject.apply_uid_validity("aaa")
-        end
+        it "sets the folder_path" do
+          subject.rename("new_name")
 
-        it "returns the new name" do
-          expect(subject.apply_uid_validity("aaa")).to eq("folder-bbb-1")
+          expect(subject.folder_path).to eq("new_name")
         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 "#rewind" do
+      before do
+        allow(File).to receive(:open).
+          with(pathname, File::RDWR | File::CREAT, 0o644).
+          and_yield(file)
+      end
 
-  describe "#update_uid" do
-    it "calls the store" do
-      expect(store).to receive(:update_uid).with("foo", "bar")
+      it "truncates the mailbox" do
+        subject.rewind(123)
 
-      subject.update_uid("foo", "bar")
+        expect(file).to have_received(:truncate).with(123)
+      end
     end
   end
 end

data/spec/unit/imap/backup/serializer_spec.rb

@@ -0,0 +1,296 @@
+module Imap::Backup
+  describe Serializer do
+    subject { described_class.new("path", "folder/sub") }
+
+    let(:directory) { instance_double(Serializer::Directory, ensure_exists: nil) }
+    let(:imap) do
+      instance_double(
+        Serializer::Imap,
+        exist?: true,
+        rename: nil,
+        uid_validity: existing_uid_validity,
+        "uid_validity=": nil
+      )
+    end
+    let(:mbox) do
+      instance_double(
+        Serializer::Mbox,
+        append: nil,
+        exist?: false,
+        length: 1,
+        pathname: "aaa",
+        rename: nil,
+        rewind: nil
+      )
+    end
+    let(:folder_path) { File.expand_path(File.join("path", "folder/sub")) }
+    let(:existing_uid_validity) { nil }
+    let(:enumerator) { instance_double(Serializer::MboxEnumerator) }
+
+    before do
+      allow(Serializer::Directory).to receive(:new) { directory }
+      allow(Serializer::Imap).to receive(:new).with(folder_path) { imap }
+      allow(Serializer::Mbox).to receive(:new) { mbox }
+      allow(Serializer::MboxEnumerator).to receive(:new) { enumerator }
+    end
+
+    describe "#apply_uid_validity" do
+      let(:imap_test) { instance_double(Serializer::Imap, exist?: imap_test_exists) }
+      let(:imap_test_exists) { false }
+      let(:test_folder_path) do
+        File.expand_path(File.join("path", "folder/sub-#{existing_uid_validity}"))
+      end
+      let(:result) { subject.apply_uid_validity("new") }
+
+      before do
+        allow(Serializer::Imap).to receive(:new).with(test_folder_path) { imap_test }
+      end
+
+      context "when there is no existing uid_validity" do
+        it "sets the metadata file's uid_validity" do
+          result
+
+          expect(imap).to have_received(:"uid_validity=").with("new")
+        end
+      end
+
+      context "when the new value is the same as the old value" do
+        let(:existing_uid_validity) { "new" }
+
+        it "does nothing" do
+          result
+
+          expect(imap).to_not have_received(:"uid_validity=")
+        end
+      end
+
+      context "when the new value is different from the old value" do
+        let(:existing_uid_validity) { "existing" }
+
+        it "renames the existing mailbox" do
+          result
+
+          expect(mbox).to have_received(:rename).with(test_folder_path)
+        end
+
+        it "renames the existing metadata file" do
+          result
+
+          expect(imap).to have_received(:rename).with(test_folder_path)
+        end
+
+        it "returns the new name for the old folder" do
+          expect(result).to eq("folder/sub-existing")
+        end
+
+        context "when the default rename is not possible" do
+          let(:imap_test_exists) { true }
+          let(:imap_test1) { instance_double(Serializer::Imap, exist?: false) }
+          let(:test_folder_path1) do
+            File.expand_path(File.join("path", "folder/sub-#{existing_uid_validity}-1"))
+          end
+
+          before do
+            allow(Serializer::Imap).to receive(:new).with(test_folder_path1) { imap_test1 }
+          end
+
+          it "renames the mailbox, appending a numeral" do
+            result
+
+            expect(mbox).to have_received(:rename).with(test_folder_path1)
+          end
+
+          it "renames the metadata file, appending a numeral" do
+            result
+
+            expect(imap).to have_received(:rename).with(test_folder_path1)
+          end
+        end
+      end
+    end
+
+    describe "#force_uid_validity" do
+      it "sets the metadata file's uid_validity" do
+        subject.force_uid_validity("new")
+
+        expect(imap).to have_received(:"uid_validity=").with("new")
+      end
+    end
+
+    describe "#append" do
+      let(:existing_uid_validity) { "42" }
+      let(:mboxrd_message) do
+        instance_double(Email::Mboxrd::Message, to_serialized: "serialized")
+      end
+      let(:uid_found) { false }
+      let(:command) { subject.append(99, "Hi") }
+
+      before do
+        allow(imap).to receive(:include?) { uid_found }
+        allow(imap).to receive(:append)
+        allow(Email::Mboxrd::Message).to receive(:new) { mboxrd_message }
+      end
+
+      it "appends the message to the mailbox" do
+        command
+
+        expect(mbox).to have_received(:append).with("serialized")
+      end
+
+      it "appends the UID to the metadata" do
+        command
+
+        expect(imap).to have_received(:append).with(99)
+      end
+
+      context "when appending to the mailbox causes an error" do
+        before do
+          allow(mbox).to receive(:append).and_throw(RuntimeError, "Boom")
+        end
+
+        it "does not fail" do
+          command
+        end
+
+        it "leaves the metadata file unchanged" do
+          command
+
+          expect(imap).to_not have_received(:append)
+        end
+      end
+
+      context "when appending to the metadata file causes an error" do
+        before do
+          allow(imap).to receive(:append).and_throw(RuntimeError, "Boom")
+        end
+
+        it "does not fail" do
+          command
+        end
+
+        it "reset the mailbox to the previous position" do
+          command
+
+          expect(mbox).to have_received(:rewind)
+        end
+      end
+
+      context "when the metadata uid_validity has not been set" do
+        let(:existing_uid_validity) { nil }
+
+        it "fails" do
+          expect { command }.to raise_error(RuntimeError, /without uid_validity/)
+        end
+      end
+
+      context "when the message has already been backed up" do
+        let(:uid_found) { true }
+
+        it "doesn't append to the mailbox file" do
+          command
+
+          expect(mbox).to_not have_received(:append)
+        end
+
+        it "doesn't append to the metadata file" do
+          command
+
+          expect(imap).to_not have_received(:append)
+        end
+      end
+    end
+
+    describe "#load" do
+      let(:uid) { 999 }
+      let(:imap_index) { 0 }
+      let(:result) { subject.load(uid) }
+
+      before do
+        allow(imap).to receive(:index).with(999) { imap_index }
+        allow(enumerator).to receive(:each) { ["message"].enum_for(:each) }
+      end
+
+      it "returns an Email::Mboxrd::Message" do
+        expect(result).to be_a(Email::Mboxrd::Message)
+      end
+
+      it "returns the message" do
+        expect(result.supplied_body).to eq("message")
+      end
+
+      context "when the message is not found" do
+        let(:imap_index) { nil }
+
+        it "returns nil" do
+          expect(result).to be nil
+        end
+      end
+
+      context "when the supplied UID is a string" do
+        let(:uid) { "999" }
+
+        it "works" do
+          expect(result).to be_a(Email::Mboxrd::Message)
+        end
+      end
+    end
+
+    describe "#load_nth" do
+      let(:imap_index) { 0 }
+      let(:result) { subject.load_nth(imap_index) }
+
+      before do
+        allow(enumerator).to receive(:each) { ["message"].enum_for(:each) }
+      end
+
+      it "returns an Email::Mboxrd::Message" do
+        expect(result).to be_a(Email::Mboxrd::Message)
+      end
+
+      it "returns the message" do
+        expect(result.supplied_body).to eq("message")
+      end
+
+      context "when the message is not found" do
+        let(:imap_index) { 1 }
+
+        it "returns nil" do
+          expect(result).to be nil
+        end
+      end
+    end
+
+    describe "#each_message" do
+      let(:good_uid) { 999 }
+
+      before do
+        allow(imap).to receive(:index) { nil }
+        allow(imap).to receive(:index).with(good_uid) { 0 }
+        allow(enumerator).to receive(:each) { ["message"].enum_for(:each) }
+      end
+
+      it "yields matching UIDs" do
+        expect { |b| subject.each_message([good_uid], &b) }.
+          to yield_successive_args([good_uid, anything])
+      end
+
+      it "yields matching messages" do
+        messages = subject.each_message([good_uid]).map { |_uid, message| message }
+        expect(messages[0].supplied_body).to eq("message")
+      end
+
+      context "with UIDs that are not present" do
+        it "skips them" do
+          expect { |b| subject.each_message([good_uid, 1234], &b) }.
+            to yield_successive_args([good_uid, anything])
+        end
+      end
+
+      context "when called without a block" do
+        it "returns an Enumerator" do
+          expect(subject.each_message([])).to be_a(Enumerator)
+        end
+      end
+    end
+  end
+end