imap-backup 2.1.1 → 2.2.0

data/spec/unit/imap/backup/account/folder_spec.rb

@@ -28,7 +28,7 @@ describe Imap::Backup::Account::Folder do
   describe "#uids" do
     let(:uids) { [5678, 123] }
 
-    before { allow(imap).to receive(:uid_search).and_return(uids) }
+    before { allow(imap).to receive(:uid_search) { uids } }
 
     it "lists available messages" do
       expect(subject.uids).to eq(uids.reverse)
@@ -83,12 +83,6 @@ describe Imap::Backup::Account::Folder do
         expect(subject.fetch(123)).to be_nil
       end
     end
-
-    it "sets the encoding on the message" do
-      subject.fetch(123)
-
-      expect(message_body).to have_received(:force_encoding).with("utf-8")
-    end
   end
 
   describe "#folder" do
@@ -117,21 +111,22 @@ describe Imap::Backup::Account::Folder do
 
   describe "#create" do
     context "when the folder exists" do
-      before { subject.create }
-
       it "is does not create the folder" do
-        expect(imap).to_not have_received(:create)
+        expect(imap).to_not receive(:create)
+
+        subject.create
       end
     end
 
     context "when the folder doesn't exist" do
       before do
         allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
-        subject.create
       end
 
       it "is does not create the folder" do
-        expect(imap).to have_received(:create)
+        expect(imap).to receive(:create)
+
+        subject.create
       end
     end
   end
@@ -168,26 +163,27 @@ describe Imap::Backup::Account::Folder do
     let(:append_response) do
       OpenStruct.new(data: OpenStruct.new(code: OpenStruct.new(data: "1 2")))
     end
-    let(:result) { subject.append(message) }
-
-    before do
-      result
-    end
 
     it "appends the message" do
-      expect(imap).to have_received(:append)
+      expect(imap).to receive(:append)
+
+      subject.append(message)
     end
 
     it "sets the date and time" do
-      expect(imap).to have_received(:append).
+      expect(imap).to receive(:append).
         with(anything, anything, anything, message_date)
+
+      subject.append(message)
     end
 
     it "returns the new uid" do
-      expect(result).to eq(2)
+      expect(subject.append(message)).to eq(2)
     end
 
     it "set the new uid validity" do
+      subject.append(message)
+
       expect(subject.uid_validity).to eq(1)
     end
   end

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

@@ -1,23 +1,6 @@
 # rubocop:disable RSpec/NestedGroups
 
 describe Imap::Backup::Configuration::Account do
-  class MockHighlineMenu
-    attr_reader :choices
-    attr_accessor :header
-
-    def initialize
-      @choices = {}
-    end
-
-    def choice(name, &block)
-      choices[name] = block
-    end
-
-    def hidden(name, &block)
-      choices[name] = block
-    end
-  end
-
   describe "#initialize" do
     subject { described_class.new(store, account, highline) }
 
@@ -35,8 +18,27 @@ describe Imap::Backup::Configuration::Account do
   describe "#run" do
     subject { described_class.new(store, account, highline) }
 
+    let(:highline_menu_class) do
+      Class.new do
+        attr_reader :choices
+        attr_accessor :header
+
+        def initialize
+          @choices = {}
+        end
+
+        def choice(name, &block)
+          choices[name] = block
+        end
+
+        def hidden(name, &block)
+          choices[name] = block
+        end
+      end
+    end
+
     let(:highline) { instance_double(HighLine) }
-    let(:menu) { MockHighlineMenu.new }
+    let(:menu) { highline_menu_class.new }
     let(:store) do
       instance_double(Imap::Backup::Configuration::Store, accounts: accounts)
     end
@@ -73,15 +75,17 @@ describe Imap::Backup::Configuration::Account do
     end
 
     describe "preparation" do
-      before { subject.run }
-
       it "clears the screen" do
-        expect(Kernel).to have_received(:system).with("clear")
+        expect(Kernel).to receive(:system).with("clear")
+
+        subject.run
       end
 
       describe "menu" do
         it "shows the menu" do
-          expect(highline).to have_received(:choose)
+          expect(highline).to receive(:choose)
+
+          subject.run
         end
       end
     end
@@ -240,8 +244,10 @@ describe Imap::Backup::Configuration::Account do
       let(:server) { "server" }
 
       before do
-        allow(highline).to receive(:ask).with("server: ").and_return(server)
+        allow(highline).to receive(:ask).with("server: ") { server }
+
         subject.run
+
         menu.choices["modify server"].call
       end
 
@@ -310,7 +316,7 @@ describe Imap::Backup::Configuration::Account do
     describe "connection test" do
       before do
         allow(Imap::Backup::Configuration::ConnectionTester).
-          to receive(:test).and_return("All fine")
+          to receive(:test) { "All fine" }
         allow(highline).to receive(:ask)
         subject.run
         menu.choices["test connection"].call
@@ -326,7 +332,7 @@ describe Imap::Backup::Configuration::Account do
       let(:confirmed) { true }
 
       before do
-        allow(highline).to receive(:agree).and_return(confirmed)
+        allow(highline).to receive(:agree) { confirmed }
         subject.run
         catch :done do
           menu.choices["delete"].call

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

@@ -30,9 +30,9 @@ module Imap::Backup
     ].each do |method, params, prompt|
       context ".#{method}" do
         it "asks for input" do
-          described_class.send(method, *params)
+          expect(highline).to receive(:ask).with("#{prompt}: ")
 
-          expect(highline).to have_received(:ask).with("#{prompt}: ")
+          described_class.send(method, *params)
         end
 
         it "returns the answer" do
@@ -56,16 +56,15 @@ module Imap::Backup
     describe "#email" do
       let(:email) { "email@example.com" }
       let(:answer) { email }
-      let(:result) { subject.email }
-
-      before { result }
 
       it "asks for an email" do
-        expect(highline).to have_received(:ask).with(/email/)
+        expect(highline).to receive(:ask).with(/email/)
+
+        subject.email
       end
 
       it "returns the address" do
-        expect(result).to eq(email)
+        expect(subject.email).to eq(email)
       end
     end
 
@@ -73,7 +72,6 @@ module Imap::Backup
       let(:password1) { "password" }
       let(:password2) { "password" }
       let(:answers) { [true, false] }
-      let(:result) { subject.password }
 
       before do
         i = 0
@@ -84,27 +82,32 @@ module Imap::Backup
           i += 1
           answer
         end
-        result
       end
 
       it "asks for a password" do
-        expect(highline).to have_received(:ask).with("password: ")
+        expect(highline).to receive(:ask).with("password: ")
+
+        subject.password
       end
 
       it "asks for confirmation" do
-        expect(highline).to have_received(:ask).with("repeat password: ")
+        expect(highline).to receive(:ask).with("repeat password: ")
+
+        subject.password
       end
 
       it "returns the password" do
-        expect(result).to eq(password1)
+        expect(subject.password).to eq(password1)
       end
 
       context "with different answers" do
         let(:password2) { "secret" }
 
         it "asks to continue" do
-          expect(highline).to have_received(:agree).
+          expect(highline).to receive(:agree).
             at_least(:once).with(/Continue\?/)
+
+          subject.password
         end
       end
     end
@@ -112,22 +115,22 @@ module Imap::Backup
     describe "#backup_path" do
       let(:path) { "/path" }
       let(:answer) { path }
-      let(:result) { subject.backup_path("", //) }
 
       before do
         allow(highline).to receive(:ask) do |&b|
           b.call query
           path
         end
-        result
       end
 
       it "asks for a directory" do
-        expect(highline).to have_received(:ask).with(/directory/)
+        expect(highline).to receive(:ask).with(/directory/)
+
+        subject.backup_path("", //)
       end
 
       it "returns the path" do
-        expect(result).to eq(path)
+        expect(subject.backup_path("", //)).to eq(path)
       end
     end
   end

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

@@ -3,32 +3,28 @@ describe Imap::Backup::Configuration::ConnectionTester do
     let(:connection) do
       instance_double(Imap::Backup::Account::Connection, imap: nil)
     end
-    let(:result) { subject.test("foo") }
 
     before do
       allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
     end
 
     describe "call" do
-      before { result }
-
       it "tries to connect" do
-        expect(connection).to have_received(:imap)
+        expect(connection).to receive(:imap)
+
+        subject.test("foo")
       end
     end
 
     describe "success" do
-      before { result }
-
       it "returns success" do
-        expect(result).to match(/successful/)
+        expect(subject.test("foo")).to match(/successful/)
       end
     end
 
     describe "failure" do
       before do
         allow(connection).to receive(:imap).and_raise(error)
-        result
       end
 
       context "with no connection" do
@@ -39,7 +35,7 @@ describe Imap::Backup::Configuration::ConnectionTester do
         end
 
         it "returns error" do
-          expect(result).to match(/no response/i)
+          expect(subject.test("foo")).to match(/no response/i)
         end
       end
 
@@ -47,7 +43,7 @@ describe Imap::Backup::Configuration::ConnectionTester do
         let(:error) { "Error" }
 
         it "returns error" do
-          expect(result).to match(/unexpected error/i)
+          expect(subject.test("foo")).to match(/unexpected error/i)
         end
       end
     end

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

@@ -22,13 +22,15 @@ describe Imap::Backup::Configuration::FolderChooser do
     end
 
     describe "display" do
-      before { subject.run }
-
       it "clears the screen" do
-        expect(Kernel).to have_received(:system).with("clear")
+        expect(Kernel).to receive(:system).with("clear")
+
+        subject.run
       end
 
       it "shows the menu" do
+        subject.run
+
         expect(output.string).to match %r{Add/remove folders}
       end
     end
@@ -114,13 +116,14 @@ describe Imap::Backup::Configuration::FolderChooser do
 
       before do
         allow(Imap::Backup::Configuration::Setup.highline).
-          to receive(:ask).and_return("q")
-        subject.run
+          to receive(:ask) { "q" }
       end
 
       it "asks to press a key" do
         expect(Imap::Backup::Configuration::Setup.highline).
-          to have_received(:ask).with("Press a key ")
+          to receive(:ask).with("Press a key ")
+
+        subject.run
       end
     end
 
@@ -129,18 +132,21 @@ describe Imap::Backup::Configuration::FolderChooser do
         allow(Imap::Backup::Account::Connection).
           to receive(:new).with(account).and_raise("error")
         allow(Imap::Backup::Configuration::Setup.highline).
-          to receive(:ask).and_return("q")
-        subject.run
+          to receive(:ask) { "q" }
       end
 
       it "prints an error message" do
         expect(Imap::Backup.logger).
-          to have_received(:warn).with("Connection failed")
+          to receive(:warn).with("Connection failed")
+
+        subject.run
       end
 
       it "asks to continue" do
         expect(Imap::Backup::Configuration::Setup.highline).
-          to have_received(:ask).with("Press a key ")
+          to receive(:ask).with("Press a key ")
+
+        subject.run
       end
     end
   end

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

@@ -35,18 +35,21 @@ describe Imap::Backup::Configuration::List do
       allow(Imap::Backup::Configuration::Store).
         to receive(:exist?) { config_exists }
       allow(Imap::Backup).to receive(:setup_logging)
-      subject.setup_logging
     end
 
     it "sets global logging level" do
-      expect(Imap::Backup).to have_received(:setup_logging).with(store)
+      expect(Imap::Backup).to receive(:setup_logging).with(store)
+
+      subject.setup_logging
     end
 
     context "without a config" do
       let(:config_exists) { false }
 
       it "does nothing" do
-        expect(Imap::Backup).to_not have_received(:setup_logging).with(store)
+        expect(Imap::Backup).to_not receive(:setup_logging).with(store)
+
+        subject.setup_logging
       end
     end
   end

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

@@ -52,15 +52,15 @@ describe Imap::Backup::Configuration::Setup do
     end
 
     it "clears the screen" do
-      subject.run
+      expect(Kernel).to receive(:system).with("clear")
 
-      expect(Kernel).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
 
     describe "listing" do
@@ -97,15 +97,15 @@ describe Imap::Backup::Configuration::Setup do
       before do
         allow(input).to receive(:gets).and_return("1\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, normal, anything).and_return(account)
-
-        subject.run
+          with(store, normal, anything) { account }
       end
 
       it "edits the account" do
-        expect(account).to have_received(:run)
+        expect(account).to receive(:run)
+
+        subject.run
       end
     end
 
@@ -125,9 +125,9 @@ describe Imap::Backup::Configuration::Setup do
       before do
         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
@@ -145,20 +145,25 @@ describe Imap::Backup::Configuration::Setup do
       context "when debug logging is disabled" do
         before do
           allow(input).to receive(:gets).and_return("start\n", "exit\n")
-          subject.run
         end
 
         it "shows a menu item" do
+          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
@@ -168,10 +173,11 @@ describe Imap::Backup::Configuration::Setup do
 
         before do
           allow(input).to receive(:gets).and_return("stop\n", "exit\n")
-          subject.run
         end
 
         it "shows a menu item" do
+          subject.run
+
           expect(output.string).to include("stop logging")
         end
 
@@ -181,11 +187,15 @@ describe Imap::Backup::Configuration::Setup do
           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
@@ -193,41 +203,46 @@ 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