imap-backup 6.0.0.rc2 → 6.1.0

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

@@ -1,218 +0,0 @@
-module Imap::Backup
-  describe Serializer::Imap do
-    subject { described_class.new(folder_path) }
-
-    let(:folder_path) { "folder_path" }
-    let(:pathname) { "folder_path.imap" }
-    let(:exists) { true }
-    let(:existing) { {uid_validity: 99, uids: [42]} }
-    let(:file) { instance_double(File, 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).and_call_original
-      allow(File).to receive(:open).with(pathname, "w").and_yield(file)
-      allow(File).to receive(:read).with(pathname) { existing.to_json }
-    end
-
-    describe "loading the metadata file" do
-      context "when it is malformed" do
-        before do
-          allow(File).to receive(:read).with(pathname).and_raise(JSON::ParserError)
-        end
-
-        it "ignores the file" do
-          subject.uid_validity
-
-          expect(subject.uids).to eq([])
-        end
-      end
-    end
-
-    describe "#append" do
-      context "when the metadata file exists" do
-        before { subject.append(123) }
-
-        it "loads the existing metadata" do
-          expect(subject.uids).to include(42)
-        end
-
-        it "appends the UID" do
-          expect(subject.uids).to include(123)
-        end
-
-        it "saves the file" do
-          expect(file).to have_received(:write).
-            with(/"uids":\[42,123\]/)
-        end
-      end
-
-      context "when the metadata file doesn't exist" do
-        let(:exists) { false }
-
-        context "when the uid_validity is set" do
-          before do
-            subject.uid_validity = 999
-          end
-
-          it "appends the UID" do
-            subject.append(123)
-
-            expect(subject.uids).to include(123)
-          end
-
-          it "saves the file" do
-            subject.append(123)
-
-            expect(file).to have_received(:write).
-              with(/"uids":\[123\]/)
-          end
-        end
-
-        context "when the uid_validity is not set" do
-          it "fails" do
-            expect do
-              subject.append(123)
-            end.to raise_error(RuntimeError, /without a uid_validity/)
-          end
-        end
-      end
-    end
-
-    describe "#exist?" do
-      context "when the metadata file exists" do
-        it "is true" do
-          expect(subject.exist?).to be true
-        end
-      end
-
-      context "when the metadata file doesn't exist" do
-        let(:exists) { false }
-
-        it "is false" do
-          expect(subject.exist?).to be false
-        end
-      end
-    end
-
-    describe "#include?" do
-      it "loads the existing metadata" do
-        subject.include?(42)
-
-        expect(File).to have_received(:read).with(pathname)
-      end
-
-      context "when there is a matching UID" do
-        it "is true" do
-          expect(subject.include?(42)).to be true
-        end
-      end
-
-      context "when there isn't a matching UID" do
-        it "is false" do
-          expect(subject.include?(99)).to be false
-        end
-      end
-    end
-
-    describe "#index" do
-      it "loads the existing metadata" do
-        subject.include?(42)
-
-        expect(File).to have_received(:read).with(pathname)
-      end
-
-      context "when there is a matching UID" do
-        it "returns the index of the matcing UID" do
-          expect(subject.index(42)).to eq(0)
-        end
-      end
-
-      context "when there isn't a matching UID" do
-        it "is nil" do
-          expect(subject.index(99)).to be nil
-        end
-      end
-    end
-
-    describe "#rename" do
-      before do
-        allow(File).to receive(:rename)
-
-        subject.rename("new_path")
-      end
-
-      context "when the metadata file exists" do
-        it "sets the folder_path" do
-          expect(subject.folder_path).to eq("new_path")
-        end
-
-        it "renames the metadata file" do
-          expect(File).to have_received(:rename).with(pathname, "new_path.imap")
-        end
-      end
-
-      context "when the metadata file doesn't exist" do
-        let(:exists) { false }
-
-        it "sets the folder_path" do
-          expect(subject.folder_path).to eq("new_path")
-        end
-
-        it "doesn't try to rename the metadata file" do
-          expect(File).to_not have_received(:rename)
-        end
-      end
-    end
-
-    describe "#uid_validity" do
-      it "returns the uid_validity" do
-        expect(subject.uid_validity).to eq(99)
-      end
-    end
-
-    describe "#uid_validity=" do
-      before { subject.uid_validity = 567 }
-
-      it "updates the uid_validity" do
-        expect(subject.uid_validity).to eq(567)
-      end
-
-      it "saves the file" do
-        expect(file).to have_received(:write).
-          with(/"uid_validity":567/)
-      end
-
-      context "when no metadata file exists" do
-        let(:exists) { false }
-
-        it "saves an empty list of UIDs" do
-          expect(file).to have_received(:write).
-            with(/"uids":\[\]/)
-        end
-      end
-    end
-
-    describe "#update_uid" do
-      before { subject.update_uid(42, 57) }
-
-      it "sets the UID" do
-        expect(subject.uids).to eq([57])
-      end
-
-      it "saves the file" do
-        expect(file).to have_received(:write).
-          with(/"uids":\[57\]/)
-      end
-
-      context "when the UID is not present" do
-        let(:existing) { {uid_validity: 99, uids: [2]} }
-
-        it "doesn't save the file" do
-          expect(file).to_not have_received(:write)
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-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,101 +0,0 @@
-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
-
-    describe "#append" do
-      it "appends the message" do
-        subject.append("message")
-
-        expect(file).to have_received(:write).with("message")
-      end
-    end
-
-    describe "#exist?" do
-      context "when the mailbox exists" do
-        it "is true" do
-          expect(subject.exist?).to be true
-        end
-      end
-
-      context "when the mailbox doesn't exist" do
-        let(:exists) { false }
-
-        it "is false" do
-          expect(subject.exist?).to be false
-        end
-      end
-    end
-
-    describe "#length" do
-      let(:stat) { instance_double(File::Stat, size: 99) }
-
-      before { allow(File).to receive(:stat) { stat } }
-
-      it "returns the length of the mailbox file" do
-        expect(subject.length).to eq(99)
-      end
-    end
-
-    describe "#pathname" do
-      it "is the folder_path plus .mbox" do
-        expect(subject.pathname).to eq("folder_path.mbox")
-      end
-    end
-
-    describe "#rename" do
-      context "when the mailbox exists" do
-        let(:exists) { true }
-
-        before do
-          allow(File).to receive(:rename)
-
-          subject.rename("new_name")
-        end
-
-        it "renames the mailbox" do
-          expect(File).to have_received(:rename)
-        end
-
-        it "sets the folder_path" do
-          expect(subject.folder_path).to eq("new_name")
-        end
-      end
-
-      context "when the mailbox doesn't exist" do
-        let(:exists) { false }
-
-        it "sets the folder_path" do
-          subject.rename("new_name")
-
-          expect(subject.folder_path).to eq("new_name")
-        end
-      end
-    end
-
-    describe "#rewind" do
-      before do
-        allow(File).to receive(:open).
-          with(pathname, File::RDWR | File::CREAT, 0o644).
-          and_yield(file)
-      end
-
-      it "truncates the mailbox" do
-        subject.rewind(123)
-
-        expect(file).to have_received(:truncate).with(123)
-      end
-    end
-  end
-end

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

@@ -1,296 +0,0 @@
-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