imap-backup 2.0.0 → 2.2.2

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

@@ -1,9 +1,9 @@
-require "spec_helper"
+# rubocop:disable RSpec/NestedGroups
 
 describe Imap::Backup::Configuration::Setup do
   include HighLineTestHelpers
 
-  context "#initialize" do
+  describe "#initialize" do
     context "without a config file" do
       it "works" do
         described_class.new
@@ -11,83 +11,105 @@ describe Imap::Backup::Configuration::Setup do
     end
   end
 
-  context "#run" do
+  describe "#run" do
+    subject { described_class.new }
+
     let(:normal) { {username: "account@example.com"} }
     let(:accounts) { [normal] }
     let(:store) do
-      double(
-        "Imap::Backup::Configuration::Store",
-        :accounts => accounts,
-        :path => "/base/path",
-        :save => nil,
-        :debug? => debug,
-        :debug= => nil,
-        :modified? => modified,
+      instance_double(
+        Imap::Backup::Configuration::Store,
+        "accounts": accounts,
+        "path": "/base/path",
+        "save": nil,
+        "debug?": debug,
+        "debug=": nil,
+        "modified?": modified
       )
     end
     let(:debug) { false }
     let(:modified) { false }
+    let!(:highline_streams) { prepare_highline }
+    let(:input) { highline_streams[0] }
+    let(:output) { highline_streams[1] }
 
-    before :each do
+    before do
       allow(Imap::Backup::Configuration::Store).to receive(:new) { store }
       allow(Imap::Backup).to receive(:setup_logging)
-      @input, @output = prepare_highline
-      allow(@input).to receive(:eof?).and_return(false)
-      allow(@input).to receive(:gets).and_return("exit\n")
-      allow(subject).to receive(:system)
+      allow(input).to receive(:eof?) { false }
+      allow(input).to receive(:gets) { "exit\n" }
+      allow(Kernel).to receive(:system)
     end
 
-    subject { described_class.new }
-
-    context "main menu" do
+    describe "main menu" do
       before { subject.run }
 
       %w(add\ account save\ and\ exit exit\ without\ saving).each do |choice|
         it "includes #{choice}" do
-          expect(@output.string).to include(choice)
+          expect(output.string).to include(choice)
         end
       end
     end
 
     it "clears the screen" do
-      subject.run
+      expect(Kernel).to receive(:system).with("clear")
 
-      expect(subject).to have_received(:system).with("clear")
+      subject.run
     end
 
     it "updates logging status" do
-      subject.run
+      expect(Imap::Backup).to receive(:setup_logging)
 
-      expect(Imap::Backup).to have_received(:setup_logging)
+      subject.run
     end
 
-    context "listing" do
+    describe "listing" do
       let(:accounts) { [normal, modified, deleted] }
       let(:modified) { {username: "modified@example.com", modified: true} }
       let(:deleted) { {username: "deleted@example.com", delete: true} }
 
       before { subject.run }
 
-      context "normal accounts" do
+      describe "normal accounts" do
         it "are listed" do
-          expect(@output.string).to match /account@example.com/
+          expect(output.string).to match(/account@example.com/)
         end
       end
 
-      context "modified accounts" do
+      describe "modified accounts" do
         it "are flagged" do
-          expect(@output.string).to match /modified@example.com \*/
+          expect(output.string).to match(/modified@example.com \*/)
         end
       end
 
-      context "deleted accounts" do
+      describe "deleted accounts" do
         it "are hidden" do
-          expect(@output.string).to_not match /delete@example.com/
+          expect(output.string).to_not match(/delete@example.com/)
         end
       end
     end
 
-    context "adding accounts" do
+    context "when editing accounts" do
+      let(:account) do
+        instance_double(Imap::Backup::Configuration::Account, run: nil)
+      end
+
+      before do
+        allow(input).to receive(:gets).and_return("1\n", "exit\n")
+        allow(Imap::Backup::Configuration::Asker).to receive(:email).
+          with(no_args) { "new@example.com" }
+        allow(Imap::Backup::Configuration::Account).to receive(:new).
+          with(store, normal, anything) { account }
+      end
+
+      it "edits the account" do
+        expect(account).to receive(:run)
+
+        subject.run
+      end
+    end
+
+    context "when adding accounts" do
       let(:blank_account) do
         {
           username: "new@example.com",
@@ -96,14 +118,16 @@ describe Imap::Backup::Configuration::Setup do
           folders: []
         }
       end
-      let(:account) { double("Imap::Backup::Configuration::Account", run: nil) }
+      let(:account) do
+        instance_double(Imap::Backup::Configuration::Account, run: nil)
+      end
 
       before do
-        allow(@input).to receive(:gets).and_return("add\n", "exit\n")
+        allow(input).to receive(:gets).and_return("add\n", "exit\n")
         allow(Imap::Backup::Configuration::Asker).to receive(:email).
-          with(no_args).and_return("new@example.com")
+          with(no_args) { "new@example.com" }
         allow(Imap::Backup::Configuration::Account).to receive(:new).
-          with(store, blank_account, anything).and_return(account)
+          with(store, blank_account, anything) { account }
 
         subject.run
       end
@@ -117,24 +141,29 @@ describe Imap::Backup::Configuration::Setup do
       end
     end
 
-    context "logging" do
+    describe "logging" do
       context "when debug logging is disabled" do
         before do
-          allow(@input).to receive(:gets).and_return("start\n", "exit\n")
-          subject.run
+          allow(input).to receive(:gets).and_return("start\n", "exit\n")
         end
 
         it "shows a menu item" do
-          expect(@output.string).to include("start logging")
+          subject.run
+
+          expect(output.string).to include("start logging")
         end
 
         context "when selected" do
           it "sets the debug flag" do
-            expect(store).to have_received(:debug=).with(true)
+            expect(store).to receive(:debug=).with(true)
+
+            subject.run
           end
 
           it "updates logging status" do
-            expect(Imap::Backup).to have_received(:setup_logging).twice
+            expect(Imap::Backup).to receive(:setup_logging).twice
+
+            subject.run
           end
         end
       end
@@ -143,25 +172,30 @@ describe Imap::Backup::Configuration::Setup do
         let(:debug) { true }
 
         before do
-          allow(@input).to receive(:gets).and_return("stop\n", "exit\n")
-          subject.run
+          allow(input).to receive(:gets).and_return("stop\n", "exit\n")
         end
 
         it "shows a menu item" do
-          expect(@output.string).to include("stop logging")
+          subject.run
+
+          expect(output.string).to include("stop logging")
         end
 
         context "when selected" do
           before do
-            allow(@input).to receive(:gets).and_return("stop\n", "exit\n")
+            allow(input).to receive(:gets).and_return("stop\n", "exit\n")
           end
 
           it "unsets the debug flag" do
-            expect(store).to have_received(:debug=).with(false)
+            expect(store).to receive(:debug=).with(false)
+
+            subject.run
           end
 
           it "updates logging status" do
-            expect(Imap::Backup).to have_received(:setup_logging).twice
+            expect(Imap::Backup).to receive(:setup_logging).twice
+
+            subject.run
           end
         end
       end
@@ -169,43 +203,50 @@ describe Imap::Backup::Configuration::Setup do
 
     context "when 'save' is selected" do
       before do
-        allow(@input).to receive(:gets).and_return("save\n")
-        subject.run
+        allow(input).to receive(:gets) { "save\n" }
       end
 
       it "exits" do
         # N.B. this will hang forever if save does not cause an exit
+        subject.run
       end
 
       it "saves the configuration" do
-        expect(store).to have_received(:save)
+        expect(store).to receive(:save)
+
+        subject.run
       end
     end
 
     context "when 'exit without saving' is selected" do
       before do
-        allow(@input).to receive(:gets).and_return("exit\n")
-
-        subject.run
+        allow(input).to receive(:gets) { "exit\n" }
       end
 
       it "exits" do
         # N.B. this will hang forever if quit does not cause an exit
+        subject.run
       end
 
       context "when the configuration is modified" do
         let(:modified) { true }
 
         it "doesn't save the configuration" do
-          expect(store).to_not have_received(:save)
+          expect(store).to_not receive(:save)
+
+          subject.run
         end
       end
 
       context "when the configuration isn't modified" do
         it "doesn't save the configuration" do
-          expect(store).to_not have_received(:save)
+          expect(store).to_not receive(:save)
+
+          subject.run
         end
       end
     end
   end
 end
+
+# rubocop:enable RSpec/NestedGroups

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

@@ -1,6 +1,7 @@
-require "spec_helper"
 require "json"
 
+# rubocop:disable RSpec/PredicateMatcher
+
 describe Imap::Backup::Configuration::Store do
   let(:directory) { "/base/path" }
   let(:file_path) { File.join(directory, "/config.json") }
@@ -19,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
@@ -46,7 +47,7 @@ describe Imap::Backup::Configuration::Store do
   end
 
   describe "#modified?" do
-    context "'with accounts flagged 'modified'" do
+    context "with accounts flagged 'modified'" do
       let(:accounts) { [{name: "foo", modified: true}] }
 
       it "is true" do
@@ -54,7 +55,7 @@ describe Imap::Backup::Configuration::Store do
       end
     end
 
-    context "'with accounts flagged 'delete'" do
+    context "with accounts flagged 'delete'" do
       let(:accounts) { [{name: "foo", delete: true}] }
 
       it "is true" do
@@ -130,28 +131,28 @@ describe Imap::Backup::Configuration::Store do
   end
 
   describe "#save" do
+    subject { described_class.new }
+
     let(:directory_exists) { false }
-    let(:file) { double("File", write: nil) }
+    let(:file) { instance_double(File, write: nil) }
 
     before do
       allow(FileUtils).to receive(:mkdir)
       allow(FileUtils).to receive(:chmod)
-      allow(File).to receive(:open).with(file_path, "w") { |&b| b.call file }
-      allow(JSON).to receive(:pretty_generate).and_return("JSON output")
+      allow(File).to receive(:open).with(file_path, "w").and_yield(file)
+      allow(JSON).to receive(:pretty_generate) { "JSON output" }
     end
 
-    subject { described_class.new }
-
     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
@@ -163,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
 
@@ -175,25 +178,25 @@ 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
 
-    context "if the configuration file is missing" do
+    context "when the configuration file is missing" do
       let(:file_exists) { false }
 
       it "doesn't fail" do
@@ -203,7 +206,7 @@ describe Imap::Backup::Configuration::Store do
       end
     end
 
-    context "if the config file permissions are too lax" do
+    context "when the config file permissions are too lax" do
       let(:file_exists) { true }
 
       before do
@@ -219,3 +222,5 @@ describe Imap::Backup::Configuration::Store do
     end
   end
 end
+
+# rubocop:enable RSpec/PredicateMatcher

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

@@ -1,41 +1,43 @@
-require "spec_helper"
-
 describe Imap::Backup::Downloader do
   describe "#run" do
+    subject { described_class.new(folder, serializer) }
+
     let(:message) { {"RFC822" => "blah"} }
     let(:folder) do
-      double("Imap::Backup::Account::Folder", fetch: message, name: "folder")
+      instance_double(
+        Imap::Backup::Account::Folder,
+        fetch: message,
+        name: "folder",
+        uids: folder_uids
+      )
+    end
+    let(:folder_uids) { %w(111 222 333) }
+    let(:serializer) do
+      instance_double(Imap::Backup::Serializer::Mbox, save: nil, uids: ["222"])
     end
-    let(:folder_uids) { ["111", "222", "333"] }
-    let(:serializer) { double("Imap::Backup::Serializer", save: nil) }
-    let(:serializer_uids) { ["222"] }
 
-    subject { described_class.new(folder, serializer) }
+    context "with fetched messages" do
+      specify "are saved" do
+        expect(serializer).to receive(:save).with("111", message)
 
-    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
+        subject.run
+      end
     end
 
-    context "#run" do
-      context "fetched messages" do
-        it "are saved" do
-          expect(serializer).to have_received(:save).with("111", message)
-        end
-      end
+    context "with messages which are already present" do
+      specify "are skipped" do
+        expect(serializer).to_not receive(:save).with("222", anything)
 
-      context "messages which are already present" do
-        specify "are skipped" do
-          expect(serializer).to_not have_received(:save).with("222", anything)
-        end
+        subject.run
       end
+    end
+
+    context "with failed fetches" do
+      specify "are skipped" do
+        allow(folder).to receive(:fetch).with("333") { nil }
+        expect(serializer).to_not receive(:save).with("333", anything)
 
-      context "failed fetches" do
-        specify "are skipped" do
-          expect(serializer).to_not have_received(:save).with("333", anything)
-        end
+        subject.run
       end
     end
   end