imap-backup 2.1.1 → 2.2.0

data/spec/unit/imap/backup/configuration/store_spec.rb

@@ -20,11 +20,11 @@ describe Imap::Backup::Configuration::Store do
     allow(File).to receive(:exist?).and_call_original
     allow(File).to receive(:exist?).with(file_path) { file_exists }
     allow(Imap::Backup::Utils).
-      to receive(:stat).with(directory).and_return(0o700)
+      to receive(:stat).with(directory) { 0o700 }
     allow(Imap::Backup::Utils).
-      to receive(:stat).with(file_path).and_return(0o600)
-    allow(Imap::Backup::Utils).to receive(:check_permissions).and_return(nil)
-    allow(File).to receive(:read).with(file_path).and_return(configuration)
+      to receive(:stat).with(file_path) { 0o600 }
+    allow(Imap::Backup::Utils).to receive(:check_permissions) { nil }
+    allow(File).to receive(:read).with(file_path) { configuration }
   end
 
   describe ".exist?" do
@@ -140,19 +140,19 @@ describe Imap::Backup::Configuration::Store do
       allow(FileUtils).to receive(:mkdir)
       allow(FileUtils).to receive(:chmod)
       allow(File).to receive(:open).with(file_path, "w").and_yield(file)
-      allow(JSON).to receive(:pretty_generate).and_return("JSON output")
+      allow(JSON).to receive(:pretty_generate) { "JSON output" }
     end
 
     it "creates the config directory" do
-      subject.save
+      expect(FileUtils).to receive(:mkdir).with(directory)
 
-      expect(FileUtils).to have_received(:mkdir).with(directory)
+      subject.save
     end
 
     it "saves the configuration" do
-      subject.save
+      expect(file).to receive(:write).with("JSON output")
 
-      expect(file).to have_received(:write).with("JSON output")
+      subject.save
     end
 
     context "when accounts are modified" do
@@ -164,7 +164,9 @@ describe Imap::Backup::Configuration::Store do
         expected = Marshal.load(Marshal.dump(data))
         expected[:accounts][0].delete(:modified)
 
-        expect(JSON).to have_received(:pretty_generate).with(expected)
+        expect(JSON).to receive(:pretty_generate).with(expected)
+
+        subject.save
       end
     end
 
@@ -176,21 +178,21 @@ describe Imap::Backup::Configuration::Store do
         ]
       end
 
-      before { subject.save }
-
       it "does not save them" do
         expected = Marshal.load(Marshal.dump(data))
         expected[:accounts].pop
 
-        expect(JSON).to have_received(:pretty_generate).with(expected)
+        expect(JSON).to receive(:pretty_generate).with(expected)
+
+        subject.save
       end
     end
 
     context "when file permissions are too open" do
-      before { subject.save }
-
       it "sets them to 0600" do
-        expect(FileUtils).to have_received(:chmod).with(0o600, file_path)
+        expect(FileUtils).to receive(:chmod).with(0o600, file_path)
+
+        subject.save
       end
     end
 

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

@@ -7,37 +7,37 @@ describe Imap::Backup::Downloader do
       instance_double(
         Imap::Backup::Account::Folder,
         fetch: message,
-        name: "folder"
+        name: "folder",
+        uids: folder_uids
       )
     end
     let(:folder_uids) { %w(111 222 333) }
     let(:serializer) do
-      instance_double(Imap::Backup::Serializer::Mbox, save: nil)
-    end
-    let(:serializer_uids) { ["222"] }
-
-    before do
-      allow(folder).to receive(:uids).and_return(folder_uids)
-      allow(serializer).to receive(:uids).and_return(serializer_uids)
-      allow(folder).to receive(:fetch).with("333").and_return(nil)
-      subject.run
+      instance_double(Imap::Backup::Serializer::Mbox, save: nil, uids: ["222"])
     end
 
     context "with fetched messages" do
-      it "are saved" do
-        expect(serializer).to have_received(:save).with("111", message)
+      specify "are saved" do
+        expect(serializer).to receive(:save).with("111", message)
+
+        subject.run
       end
     end
 
     context "with messages which are already present" do
       specify "are skipped" do
-        expect(serializer).to_not have_received(:save).with("222", anything)
+        expect(serializer).to_not receive(:save).with("222", anything)
+
+        subject.run
       end
     end
 
     context "with failed fetches" do
       specify "are skipped" do
-        expect(serializer).to_not have_received(:save).with("333", anything)
+        allow(folder).to receive(:fetch).with("333") { nil }
+        expect(serializer).to_not receive(:save).with("333", anything)
+
+        subject.run
       end
     end
   end

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

@@ -21,11 +21,16 @@ describe Imap::Backup::Serializer::MboxEnumerator do
 
   before do
     allow(File).to receive(:open).and_call_original
-    allow(File).to receive(:open).with(mbox_pathname).and_yield(mbox_file)
+    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)

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

@@ -28,8 +28,6 @@ describe Imap::Backup::Serializer::Mbox do
   end
 
   describe "folder path" do
-    before { subject.uids }
-
     context "when it has multiple elements" do
       let(:imap_folder) { "folder/path" }
 
@@ -37,8 +35,10 @@ describe Imap::Backup::Serializer::Mbox 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
@@ -48,57 +48,66 @@ describe Imap::Backup::Serializer::Mbox do
 
       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 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 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)
+
+        subject.uids
       end
     end
   end
 
   describe "#apply_uid_validity" do
-    let(:result) { subject.apply_uid_validity("aaa") }
-
     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
 
@@ -113,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
 
@@ -134,67 +146,69 @@ 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
-    before { subject.force_uid_validity("66") }
-
     it "sets the uid_validity" do
-      expect(store).to have_received(:uid_validity=).with("66")
+      expect(store).to receive(:uid_validity=).with("66")
+
+      subject.force_uid_validity("66")
     end
   end
 
   describe "#uids" do
     it "calls the store" do
-      subject.uids
+      expect(store).to receive(:uids)
 
-      expect(store).to have_received(:uids)
+      subject.uids
     end
   end
 
   describe "#load" do
-    let(:result) { subject.load("66") }
-
     before { allow(store).to receive(:load).with("66") { "xxx" } }
 
     it "returns the value loaded by the store" do
-      expect(result).to eq("xxx")
+      expect(subject.load("66")).to eq("xxx")
     end
   end
 
   describe "#save" do
-    before { subject.save("foo", "bar") }
-
     it "calls the store" do
-      expect(store).to have_received(:add).with("foo", "bar")
+      expect(store).to receive(:add).with("foo", "bar")
+
+      subject.save("foo", "bar")
     end
   end
 
   describe "#rename" do
-    before { subject.rename("foo") }
-
     it "calls the store" do
-      expect(store).to have_received(:rename).with("foo")
+      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
-    before { subject.update_uid("foo", "bar") }
-
     it "calls the store" do
-      expect(store).to have_received(:update_uid).with("foo", "bar")
+      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

@@ -51,14 +51,16 @@ describe Imap::Backup::Serializer::MboxStore do
       }.to_json
     end
 
-    before { subject.uid_validity = new_uid_validity }
-
     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 have_received(:write).with(updated_imap_content)
+      expect(imap_file).to receive(:write).with(updated_imap_content)
+
+      subject.uid_validity = new_uid_validity
     end
   end
 
@@ -80,22 +82,26 @@ describe Imap::Backup::Serializer::MboxStore do
         allow(JSON).to receive(:parse).and_raise(JSON::ParserError)
       end
 
-      let!(:result) { subject.uids }
-
       it "returns an empty Array" do
-        expect(result).to eq([])
+        expect(subject.uids).to eq([])
       end
 
       it "deletes the imap file" do
-        expect(File).to have_received(:unlink).with(imap_pathname)
+        expect(File).to receive(:unlink).with(imap_pathname)
+
+        subject.uids
       end
 
       it "deletes the mbox file" do
-        expect(File).to have_received(:unlink).with(mbox_pathname)
+        expect(File).to receive(:unlink).with(mbox_pathname)
+
+        subject.uids
       end
 
       it "writes a blank mbox file" do
-        expect(mbox_file).to have_received(:write).with("")
+        expect(mbox_file).to receive(:write).with("")
+
+        subject.uids
       end
     end
 
@@ -126,28 +132,29 @@ describe Imap::Backup::Serializer::MboxStore do
     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 }
     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
-      subject.add(message_uid, "The\nemail\n")
+      expect(imap_file).to receive(:write).with(updated_imap_content)
 
-      expect(imap_file).to have_received(:write).with(updated_imap_content)
+      subject.add(message_uid, "The\nemail\n")
     end
 
     context "when the message is already downloaded" do
       let(:uids) { [999] }
 
       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
     end
 
@@ -157,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
@@ -171,7 +179,6 @@ describe Imap::Backup::Serializer::MboxStore do
 
   describe "#load" do
     let(:uid) { "1" }
-    let(:result) { subject.load(uid) }
     let(:enumerator) do
       instance_double(Imap::Backup::Serializer::MboxEnumerator)
     end
@@ -189,14 +196,14 @@ describe Imap::Backup::Serializer::MboxStore do
     end
 
     it "returns the message" do
-      expect(result.supplied_body).to eq("ciao")
+      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(result).to be_nil
+        expect(subject.load(uid)).to be_nil
       end
     end
   end
@@ -211,34 +218,40 @@ describe Imap::Backup::Serializer::MboxStore do
       }.to_json
     end
 
-    before { subject.update_uid(old_uid, "999") }
-
     it "updates the stored UID" do
-      expect(imap_file).to have_received(:write).with(updated_imap_content)
+      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 have_received(:write)
+        expect(imap_file).to_not receive(:write)
+
+        subject.update_uid(old_uid, "999")
       end
     end
   end
 
   describe "#reset" do
-    before { subject.reset }
-
     it "deletes the imap file" do
-      expect(File).to have_received(:unlink).with(imap_pathname)
+      expect(File).to receive(:unlink).with(imap_pathname)
+
+      subject.reset
     end
 
     it "deletes the mbox file" do
-      expect(File).to have_received(:unlink).with(mbox_pathname)
+      expect(File).to receive(:unlink).with(mbox_pathname)
+
+      subject.reset
     end
 
     it "writes a blank mbox file" do
-      expect(mbox_file).to have_received(:write).with("")
+      expect(mbox_file).to receive(:write).with("")
+
+      subject.reset
     end
   end
 
@@ -252,18 +265,23 @@ describe Imap::Backup::Serializer::MboxStore 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)
-      subject.rename(new_name)
     end
 
     it "renames the imap file" do
-      expect(File).to have_received(:rename).with(imap_pathname, new_imap_name)
+      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 have_received(:rename).with(mbox_pathname, new_mbox_name)
+      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