imap-backup 2.0.0 → 2.2.2

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

@@ -1,6 +1,8 @@
-require "spec_helper"
+# rubocop:disable RSpec/PredicateMatcher
 
 describe Imap::Backup::Account::Folder do
+  subject { described_class.new(connection, "my_folder") }
+
   let(:imap) do
     instance_double(
       Net::IMAP,
@@ -10,25 +12,23 @@ describe Imap::Backup::Account::Folder do
       responses: responses
     )
   end
-  let(:connection) { double("Imap::Backup::Account::Connection", imap: imap) }
-  let(:missing_mailbox_data) do
-    double("Data", text: "Unknown Mailbox: my_folder")
+  let(:connection) do
+    instance_double(Imap::Backup::Account::Connection, imap: imap)
   end
-  let(:missing_mailbox_response) do
-    double("Response", data: missing_mailbox_data)
+  let(:missing_mailbox_data) do
+    OpenStruct.new(text: "Unknown Mailbox: my_folder")
   end
+  let(:missing_mailbox_response) { OpenStruct.new(data: missing_mailbox_data) }
   let(:missing_mailbox_error) do
     Net::IMAP::NoResponseError.new(missing_mailbox_response)
   end
   let(:responses) { [] }
   let(:append_response) { nil }
 
-  subject { described_class.new(connection, "my_folder") }
-
-  context "#uids" 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)
@@ -43,10 +43,24 @@ describe Imap::Backup::Account::Folder do
         expect(subject.uids).to eq([])
       end
     end
+
+    context "with no SEARCH response in Net::IMAP" do
+      let(:no_method_error) do
+        NoMethodError.new("Somethimes SEARCH responses come out undefined")
+      end
+
+      before do
+        allow(imap).to receive(:examine).and_raise(no_method_error)
+      end
+
+      it "returns an empty array" do
+        expect(subject.uids).to eq([])
+      end
+    end
   end
 
-  context "#fetch" do
-    let(:message_body) { double("the body", force_encoding: nil) }
+  describe "#fetch" do
+    let(:message_body) { instance_double(String, force_encoding: nil) }
     let(:attributes) { {"RFC822" => message_body, "other" => "xxx"} }
     let(:fetch_data_item) do
       instance_double(Net::IMAP::FetchData, attr: attributes)
@@ -58,7 +72,7 @@ describe Imap::Backup::Account::Folder do
       expect(subject.fetch(123)).to eq(attributes)
     end
 
-    context "if the server responds with nothing" do
+    context "when the server responds with nothing" do
       before { allow(imap).to receive(:uid_fetch) { nil } }
 
       it "is nil" do
@@ -66,7 +80,7 @@ describe Imap::Backup::Account::Folder do
       end
     end
 
-    context "if the mailbox doesn't exist" do
+    context "when the mailbox doesn't exist" do
       before do
         allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
       end
@@ -76,20 +90,22 @@ describe Imap::Backup::Account::Folder do
       end
     end
 
-    it "sets the encoding on the message" do
-      subject.fetch(123)
+    context "when the response doesn't have RFC822" do
+      let(:attributes) { {} }
 
-      expect(message_body).to have_received(:force_encoding).with("utf-8")
+      it "is nil" do
+        expect(subject.fetch(123)).to be_nil
+      end
     end
   end
 
-  context "#folder"  do
+  describe "#folder" do
     it "is the name" do
       expect(subject.folder).to eq("my_folder")
     end
   end
 
-  context "#exist?" do
+  describe "#exist?" do
     context "when the folder exists" do
       it "is true" do
         expect(subject.exist?).to be_truthy
@@ -107,62 +123,84 @@ describe Imap::Backup::Account::Folder do
     end
   end
 
-  context "#create" 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
 
-  context "#uid_validity" do
+  describe "#uid_validity" do
     let(:responses) { {"UIDVALIDITY" => ["x", "uid validity"]} }
 
     it "is returned" do
       expect(subject.uid_validity).to eq("uid validity")
     end
+
+    context "when the folder doesn't exist" do
+      before do
+        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+      end
+
+      it "raises an error" do
+        expect do
+          subject.uid_validity
+        end.to raise_error(Imap::Backup::FolderNotFound)
+      end
+    end
   end
 
-  context "#append" do
+  describe "#append" do
     let(:message) do
       instance_double(
         Email::Mboxrd::Message,
         imap_body: "imap body",
-        date: Time.now
+        date: message_date
       )
     end
-    let(:append_response) { "response" }
-    let(:result) { subject.append(message) }
-
-    before do
-      allow(append_response).
-        to receive_message_chain("data.code.data") { "1 2" }
-      result
+    let(:message_date) { Time.new(2010, 10, 10, 9, 15, 22, 0) }
+    let(:append_response) do
+      OpenStruct.new(data: OpenStruct.new(code: OpenStruct.new(data: "1 2")))
     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 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
 end
+
+# rubocop:enable RSpec/PredicateMatcher

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

@@ -1,30 +1,13 @@
-require "spec_helper"
+# 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) }
 
-  context "#initialize" do
     let(:store) { "store" }
     let(:account) { "account" }
     let(:highline) { "highline" }
 
-    subject { described_class.new(store, account, highline) }
-
     [:store, :account, :highline].each do |param|
       it "expects #{param}" do
         expect(subject.send(param)).to eq(send(param))
@@ -32,11 +15,32 @@ describe Imap::Backup::Configuration::Account do
     end
   end
 
-  context "#run" do
-    let(:highline) { double("Highline") }
-    let(:menu) { MockHighlineMenu.new }
+  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) { highline_menu_class.new }
     let(:store) do
-      double("Imap::Backup::Configuration::Store", accounts: accounts)
+      instance_double(Imap::Backup::Configuration::Store, accounts: accounts)
     end
     let(:accounts) { [account, account1] }
     let(:account) do
@@ -45,13 +49,13 @@ describe Imap::Backup::Configuration::Account do
         server: existing_server,
         local_path: "/backup/path",
         folders: [{name: "my_folder"}],
-        password: existing_password,
+        password: existing_password
       }
     end
     let(:account1) do
       {
         username: other_email,
-        local_path: other_existing_path,
+        local_path: other_existing_path
       }
     end
     let(:existing_email) { "user@example.com" }
@@ -62,31 +66,31 @@ describe Imap::Backup::Configuration::Account do
     let(:other_existing_path) { "/other/existing/path" }
 
     before do
-      allow(subject).to receive(:system).and_return(nil)
-      allow(subject).to receive(:puts).and_return(nil)
+      allow(Kernel).to receive(:system)
+      allow(Kernel).to receive(:puts)
       allow(highline).to receive(:choose) do |&block|
         block.call(menu)
         throw :done
       end
     end
 
-    subject { described_class.new(store, account, highline) }
-
-    context "preparation" do
-      before { subject.run }
-
+    describe "preparation" do
       it "clears the screen" do
-        expect(subject).to have_received(:system).with("clear")
+        expect(Kernel).to receive(:system).with("clear")
+
+        subject.run
       end
 
-      context "menu" do
+      describe "menu" do
         it "shows the menu" do
-          expect(highline).to have_received(:choose)
+          expect(highline).to receive(:choose)
+
+          subject.run
         end
       end
     end
 
-    context "menu" do
+    describe "menu" do
       [
         "modify email",
         "modify password",
@@ -96,7 +100,7 @@ describe Imap::Backup::Configuration::Account do
         "test connection",
         "delete",
         "return to main menu",
-        "quit", # TODO: quit is hidden
+        "quit" # TODO: quit is hidden
       ].each do |item|
         before { subject.run }
 
@@ -106,7 +110,7 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context "account details" do
+    describe "account details" do
       [
         ["email", /email:\s+user@example.com/],
         ["server", /server:\s+imap.example.com/],
@@ -132,7 +136,7 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context "email" do
+    describe "email" do
       before do
         allow(Imap::Backup::Configuration::Asker).
           to receive(:email) { new_email }
@@ -140,7 +144,7 @@ describe Imap::Backup::Configuration::Account do
         menu.choices["modify email"].call
       end
 
-      context "if the server is blank" do
+      context "when the server is blank" do
         [
           ["GMail", "foo@gmail.com", "imap.gmail.com"],
           ["Fastmail", "bar@fastmail.fm", "imap.fastmail.com"],
@@ -166,9 +170,24 @@ describe Imap::Backup::Configuration::Account do
             end
           end
         end
+
+        context "when the domain is unrecognized" do
+          let(:existing_server) { nil }
+          let(:provider) do
+            instance_double(Email::Provider, provider: :default)
+          end
+
+          before do
+            allow(Email::Provider).to receive(:for_address) { provider }
+          end
+
+          it "does not set a default server" do
+            expect(account[:server]).to be_nil
+          end
+        end
       end
 
-      context "the email is new" do
+      context "when the email is new" do
         it "modifies the email address" do
           expect(account[:username]).to eq(new_email)
         end
@@ -176,11 +195,11 @@ describe Imap::Backup::Configuration::Account do
         include_examples "it flags the account as modified"
       end
 
-      context "the email already exists" do
+      context "when the email already exists" do
         let(:new_email) { other_email }
 
         it "indicates the error" do
-          expect(subject).to have_received(:puts).
+          expect(Kernel).to have_received(:puts).
             with("There is already an account set up with that email address")
         end
 
@@ -192,7 +211,7 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context "password" do
+    describe "password" do
       let(:new_password) { "new_password" }
 
       before do
@@ -202,7 +221,7 @@ describe Imap::Backup::Configuration::Account do
         menu.choices["modify password"].call
       end
 
-      context "if the user enters a password" do
+      context "when the user enters a password" do
         it "updates the password" do
           expect(account[:password]).to eq(new_password)
         end
@@ -210,7 +229,7 @@ describe Imap::Backup::Configuration::Account do
         include_examples "it flags the account as modified"
       end
 
-      context "if the user cancels" do
+      context "when the user cancels" do
         let(:new_password) { nil }
 
         it "does nothing" do
@@ -221,15 +240,14 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context "server" do
+    describe "server" do
       let(:server) { "server" }
 
       before do
-        allow(highline).to receive(:ask).with("server: ").and_return(server)
-      end
+        allow(highline).to receive(:ask).with("server: ") { server }
 
-      before do
         subject.run
+
         menu.choices["modify server"].call
       end
 
@@ -240,14 +258,14 @@ describe Imap::Backup::Configuration::Account do
       include_examples "it flags the account as modified"
     end
 
-    context "backup_path" do
+    describe "backup_path" do
       let(:new_backup_path) { "/new/path" }
 
       before do
         @validator = nil
         allow(
           Imap::Backup::Configuration::Asker
-        ).to receive(:backup_path) do |path, validator|
+        ).to receive(:backup_path) do |_path, validator|
           @validator = validator
           new_backup_path
         end
@@ -259,15 +277,29 @@ describe Imap::Backup::Configuration::Account do
         expect(account[:local_path]).to eq(new_backup_path)
       end
 
-      it "validates that the path is not used by other backups" do
-        expect(@validator.call(other_existing_path)).to be_falsey
+      context "when the path is not used by other backups" do
+        it "is accepts it" do
+          # rubocop:disable RSpec/InstanceVariable
+          expect(@validator.call("/unknown/path")).to be_truthy
+          # rubocop:enable RSpec/InstanceVariable
+        end
+      end
+
+      context "when the path is used by other backups" do
+        it "fails validation" do
+          # rubocop:disable RSpec/InstanceVariable
+          expect(@validator.call(other_existing_path)).to be_falsey
+          # rubocop:enable RSpec/InstanceVariable
+        end
       end
 
       include_examples "it flags the account as modified"
     end
 
-    context "folders" do
-      let(:chooser) { double(run: nil) }
+    describe "folders" do
+      let(:chooser) do
+        instance_double(Imap::Backup::Configuration::FolderChooser, run: nil)
+      end
 
       before do
         allow(Imap::Backup::Configuration::FolderChooser).
@@ -281,10 +313,10 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context "connection test" 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
@@ -296,11 +328,11 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context "deletion" do
+    describe "deletion" 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
@@ -323,3 +355,5 @@ describe Imap::Backup::Configuration::Account do
     end
   end
 end
+
+# rubocop:enable RSpec/NestedGroups