imap-backup 5.0.0 → 6.0.0.rc2

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

@@ -0,0 +1,42 @@
+module Imap::Backup
+  describe Sanitizer do
+    require "stringio"
+
+    subject { described_class.new(output) }
+
+    let(:output) { StringIO.new }
+
+    describe "#puts" do
+      it "delegates to output" do
+        subject.puts("x")
+
+        expect(output.string).to eq("x\n")
+      end
+    end
+
+    describe "#write" do
+      it "delegates to output" do
+        subject.write("x")
+
+        expect(output.string).to eq("x")
+      end
+    end
+
+    describe "#print" do
+      it "removes passwords from complete lines of text" do
+        subject.print("C: RUBY99 LOGIN xx) secret!!!!\netc")
+
+        expect(output.string).to eq("C: RUBY99 LOGIN xx) [PASSWORD REDACTED]\n")
+      end
+    end
+
+    describe "#flush" do
+      it "sanitizes remaining text" do
+        subject.print("before\nC: RUBY99 LOGIN xx) secret!!!!")
+        subject.flush
+
+        expect(output.string).to eq("before\nC: RUBY99 LOGIN xx) [PASSWORD REDACTED]\n")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Imap::Backup
+  describe Serializer::Directory do
+    subject { described_class.new("path", "relative") }
+
+    let(:windows) { false }
+
+    before do
+      allow(File).to receive(:directory?) { false }
+      allow(Utils).to receive(:make_folder)
+      allow(OS).to receive(:windows?) { windows }
+      allow(Utils).to receive(:mode) { 0o600 }
+      allow(FileUtils).to receive(:chmod)
+
+      subject.ensure_exists
+    end
+
+    describe "#ensure_exists" do
+      context "when the directory doesn't exist" do
+        it "makes the directory" do
+          expect(Utils).to have_received(:make_folder)
+        end
+      end
+
+      it "sets permissions" do
+        expect(FileUtils).to have_received(:chmod)
+      end
+
+      context "when on Windows" do
+        let(:windows) { true }
+
+        it "doesn't set permissions" do
+          expect(FileUtils).to_not have_received(:chmod)
+        end
+      end
+    end
+  end
+end

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

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