imap-backup 2.0.0 → 2.2.2

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

@@ -1,40 +1,38 @@
-require "spec_helper"
-
 module Imap::Backup
   describe Configuration::Asker do
+    subject { described_class.new(highline) }
+
     let(:highline) { double }
     let(:query) do
-      double(
-        "Query",
-        :default= => nil,
-        :readline= => nil,
-        :validate= => nil,
-        :responses => {},
-        :echo= => nil
+      instance_double(
+        HighLine::Question,
+        "default=": nil,
+        "readline=": nil,
+        "validate=": nil,
+        "responses": {},
+        "echo=": nil
       )
     end
     let(:answer) { "foo" }
 
     before do
-      allow(Configuration::Setup).to receive(:highline).and_return(highline)
+      allow(Configuration::Setup).to receive(:highline) { highline }
       allow(highline).to receive(:ask) do |&b|
         b.call query
         answer
       end
     end
 
-    subject { described_class.new(highline) }
-
     [
       [:email, [], "email address"],
       [:password, [], "password"],
-      [:backup_path, ["x", "y"], "backup directory"]
+      [:backup_path, %w(x y), "backup directory"]
     ].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
@@ -43,7 +41,7 @@ module Imap::Backup
       end
     end
 
-    context "#initialize" do
+    describe "#initialize" do
       it "requires 1 parameter" do
         expect do
           described_class.new
@@ -55,67 +53,66 @@ module Imap::Backup
       end
     end
 
-    context "#email" do
+    describe "#email" do
       let(:email) { "email@example.com" }
       let(:answer) { email }
 
-      before do
-        @result = subject.email
-      end
-
       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
 
-    context "#password" do
+    describe "#password" do
       let(:password1) { "password" }
       let(:password2) { "password" }
-      let(:answers) { [answer1, answer2] }
-      let(:answer1) { true }
-      let(:answer2) { false }
+      let(:answers) { [true, false] }
 
       before do
-        @i = 0
-        allow(highline).to receive(:ask).
-          with("password: ").and_return(password1)
-        allow(highline).to receive(:ask).
-          with("repeat password: ").and_return(password2)
+        i = 0
+        allow(highline).to receive(:ask).with("password: ") { password1 }
+        allow(highline).to receive(:ask).with("repeat password: ") { password2 }
         allow(highline).to receive(:agree) do
-          answer = answers[@i]
-          @i += 1
+          answer = answers[i]
+          i += 1
           answer
         end
-        @result = subject.password
       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 "different answers" do
+      context "with different answers" do
         let(:password2) { "secret" }
 
         it "asks to continue" do
-          expect(highline).to have_received(:agree).
-            at_least(1).times.with(/Continue\?/)
+          expect(highline).to receive(:agree).
+            at_least(:once).with(/Continue\?/)
+
+          subject.password
         end
       end
     end
 
-    context "#backup_path" do
+    describe "#backup_path" do
       let(:path) { "/path" }
       let(:answer) { path }
 
@@ -124,15 +121,16 @@ module Imap::Backup
           b.call query
           path
         end
-        @result = subject.backup_path("", //)
       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

@@ -1,50 +1,49 @@
-require "spec_helper"
-
 describe Imap::Backup::Configuration::ConnectionTester do
-  context ".test" do
-    let(:connection) { double("Imap::Backup::Account::Connection", imap: nil) }
+  describe ".test" do
+    let(:connection) do
+      instance_double(Imap::Backup::Account::Connection, imap: nil)
+    end
 
     before do
       allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
     end
 
-    context "call" do
-      before { @result = subject.test("foo") }
-
+    describe "call" do
       it "tries to connect" do
-        expect(connection).to have_received(:imap)
+        expect(connection).to receive(:imap)
+
+        subject.test("foo")
       end
     end
 
-    context "success" do
-      before { @result = subject.test("foo") }
-
+    describe "success" do
       it "returns success" do
-        expect(@result).to match(/successful/)
+        expect(subject.test("foo")).to match(/successful/)
       end
     end
 
-    context "failure" do
+    describe "failure" do
       before do
         allow(connection).to receive(:imap).and_raise(error)
-        @result = subject.test("foo")
       end
 
-      context "no connection" do
+      context "with no connection" do
         let(:error) do
-          data = double("foo", text: "bar")
-          Net::IMAP::NoResponseError.new(double("o", data: data))
+          data = OpenStruct.new(text: "bar")
+          response = OpenStruct.new(data: data)
+          Net::IMAP::NoResponseError.new(response)
         end
 
-        it "returns success" do
-          expect(@result).to match(/no response/i)
+        it "returns error" do
+          expect(subject.test("foo")).to match(/no response/i)
         end
       end
 
-      context "other" do
+      context "when caused by other errors" do
         let(:error) { "Error" }
-        it "returns success" do
-          expect(@result).to match(/unexpected error/i)
+
+        it "returns error" do
+          expect(subject.test("foo")).to match(/unexpected error/i)
         end
       end
     end

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

@@ -1,61 +1,68 @@
-require "spec_helper"
-
 describe Imap::Backup::Configuration::FolderChooser do
   include HighLineTestHelpers
 
-  context "#run" do
+  describe "#run" do
+    subject { described_class.new(account) }
+
     let(:connection) do
-      double("Imap::Backup::Account::Connection", folders: remote_folders)
+      instance_double(
+        Imap::Backup::Account::Connection, folders: remote_folders
+      )
     end
     let(:account) { {folders: []} }
     let(:remote_folders) { [] }
-
-    subject { described_class.new(account) }
+    let!(:highline_streams) { prepare_highline }
+    let(:input) { highline_streams[0] }
+    let(:output) { highline_streams[1] }
 
     before do
-      allow(Imap::Backup::Account::Connection).
-        to receive(:new).with(account) { connection }
-      @input, @output = prepare_highline
-      allow(subject).to receive(:system)
+      allow(Imap::Backup::Account::Connection).to receive(:new) { connection }
+      allow(Kernel).to receive(:system)
       allow(Imap::Backup.logger).to receive(:warn)
     end
 
-    context "display" do
-      before { subject.run }
-
+    describe "display" do
       it "clears the screen" do
-        expect(subject).to have_received(:system).with("clear")
+        expect(Kernel).to receive(:system).with("clear")
+
+        subject.run
       end
 
-      it "should show the menu" do
-        expect(@output.string).to match %r{Add/remove folders}
+      it "shows the menu" do
+        subject.run
+
+        expect(output.string).to match %r{Add/remove folders}
       end
     end
 
-    context "folder listing" do
+    describe "folder listing" do
       let(:account) { {folders: [{name: "my_folder"}]} }
       let(:remote_folders) do
         # this one is already backed up:
-        folder1 = double("folder", name: "my_folder")
-        folder2 = double("folder", name: "another_folder")
+        folder1 = instance_double(
+          Imap::Backup::Account::Folder, name: "my_folder"
+        )
+        folder2 = instance_double(
+          Imap::Backup::Account::Folder, name: "another_folder"
+        )
         [folder1, folder2]
       end
 
-      context "display" do
+      describe "display" do
         before { subject.run }
 
         it "shows folders which are being backed up" do
-          expect(@output.string).to include("+ my_folder")
+          expect(output.string).to include("+ my_folder")
         end
 
         it "shows folders which are not being backed up" do
-          expect(@output.string).to include("- another_folder")
+          expect(output.string).to include("- another_folder")
         end
       end
 
-      context "adding folders" do
+      context "when adding folders" do
         before do
-          allow(@input).to receive(:gets).and_return("2\n", "q\n")
+          allow(input).to receive(:gets).and_return("2\n", "q\n")
 
           subject.run
         end
@@ -67,9 +74,9 @@ describe Imap::Backup::Configuration::FolderChooser do
         include_examples "it flags the account as modified"
       end
 
-      context "removing folders" do
+      context "when removing folders" do
         before do
-          allow(@input).to receive(:gets).and_return("1\n", "q\n")
+          allow(input).to receive(:gets).and_return("1\n", "q\n")
 
           subject.run
         end
@@ -82,18 +89,41 @@ describe Imap::Backup::Configuration::FolderChooser do
       end
     end
 
+    context "with missing remote folders" do
+      let(:account) do
+        {folders: [{name: "on_server"}, {name: "not_on_server"}]}
+      end
+      let(:remote_folders) do
+        [
+          instance_double(Imap::Backup::Account::Folder, name: "on_server")
+        ]
+      end
+
+      before do
+        allow(Kernel).to receive(:puts)
+        subject.run
+      end
+
+      specify "are removed from the account" do
+        expect(account[:folders]).to_not include(name: "not_on_server")
+      end
+
+      include_examples "it flags the account as modified"
+    end
+
     context "when folders are not available" do
       let(:remote_folders) { nil }
 
       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
 
@@ -102,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

@@ -1,6 +1,6 @@
-require "spec_helper"
-
 describe Imap::Backup::Configuration::List do
+  subject { described_class.new }
+
   let(:accounts) do
     [
       {username: "a1@example.com"},
@@ -8,14 +8,14 @@ describe Imap::Backup::Configuration::List do
     ]
   end
   let(:store) do
-    double("Imap::Backup::Configuration::Store", accounts: accounts)
+    instance_double(Imap::Backup::Configuration::Store, accounts: accounts)
   end
   let(:exists) { true }
   let(:connection1) do
-    double("Imap::Backup::Account::Connection", disconnect: nil)
+    instance_double(Imap::Backup::Account::Connection, disconnect: nil)
   end
   let(:connection2) do
-    double("Imap::Backup::Account::Connection", disconnect: nil)
+    instance_double(Imap::Backup::Account::Connection, disconnect: nil)
   end
 
   before do
@@ -28,12 +28,33 @@ describe Imap::Backup::Configuration::List do
       to receive(:new).with(accounts[1]) { connection2 }
   end
 
-  subject { described_class.new }
+  describe "#setup_logging" do
+    let(:config_exists) { true }
+
+    before do
+      allow(Imap::Backup::Configuration::Store).
+        to receive(:exist?) { config_exists }
+      allow(Imap::Backup).to receive(:setup_logging)
+    end
+
+    it "sets global logging level" do
+      expect(Imap::Backup).to receive(:setup_logging).with(store)
 
-  context "#initialize" do
+      subject.setup_logging
+    end
+
+    context "without a config" do
+      let(:config_exists) { false }
+
+      it "does nothing" do
+        expect(Imap::Backup).to_not receive(:setup_logging).with(store)
+
+        subject.setup_logging
+      end
+    end
   end
 
-  context "#each_connection" do
+  describe "#each_connection" do
     specify "calls the block with each account's connection" do
       connections = []
 
@@ -45,7 +66,7 @@ describe Imap::Backup::Configuration::List do
     context "with account parameter" do
       subject { described_class.new(["a2@example.com"]) }
 
-      it "should only create requested accounts" do
+      it "only creates requested accounts" do
         connections = []
 
         subject.each_connection { |a| connections << a }
@@ -58,9 +79,9 @@ describe Imap::Backup::Configuration::List do
       let(:exists) { false }
 
       it "fails" do
-        expect {
+        expect do
           subject.each_connection {}
-        }.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)
+        end.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)
       end
     end
   end