imap-backup 1.2.2 → 1.2.3

data/spec/unit/account/connection_spec.rb

@@ -1,28 +1,27 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Account::Connection do
   def self.backup_folder
-    'backup_folder'
+    "backup_folder"
   end
 
   def self.folder_config
-    {:name => backup_folder}
+    {name: backup_folder}
   end
 
-  let(:imap) { double('Net::IMAP', :login => nil, :list => imap_folders, :disconnect => nil) }
+  let(:imap) { double("Net::IMAP", login: nil, list: imap_folders, disconnect: nil) }
   let(:imap_folders) { [] }
   let(:options) do
     {
-      :username => username,
-      :password => 'password',
-      :local_path => local_path,
-      :folders => backup_folders,
+      username: username,
+      password: "password",
+      local_path: local_path,
+      folders: backup_folders,
     }
   end
-  let(:local_path) { 'local_path' }
+  let(:local_path) { "local_path" }
   let(:backup_folders) { [self.class.folder_config] }
-  let(:username) { 'username@gmail.com' }
+  let(:username) { "username@gmail.com" }
 
   before do
     allow(Net::IMAP).to receive(:new).and_return(imap)
@@ -31,88 +30,88 @@ describe Imap::Backup::Account::Connection do
 
   subject { described_class.new(options) }
 
-  shared_examples 'connects to IMAP' do
-    it 'sets up the IMAP connection' do
+  shared_examples "connects to IMAP" do
+    it "sets up the IMAP connection" do
       expect(Net::IMAP).to have_received(:new)
     end
 
-    it 'logs in to the imap server' do
+    it "logs in to the imap server" do
       expect(imap).to have_received(:login)
     end
   end
 
-  context '#initialize' do
+  context "#initialize" do
     [
-      [:username, 'username@gmail.com'],
-      [:local_path, 'local_path'],
-      [:backup_folders, [folder_config]],
+      [:username, "username@gmail.com"],
+      [:local_path, "local_path"],
+      [:backup_folders, [folder_config]]
     ].each do |attr, expected|
       it "expects #{attr}" do
         expect(subject.send(attr)).to eq(expected)
       end
     end
 
-    it 'creates the path' do
+    it "creates the path" do
       subject.username
       expect(Imap::Backup::Utils).to have_received(:make_folder)
     end
   end
 
-  describe '#imap' do
+  describe "#imap" do
     before { @result = subject.imap }
 
-    it 'returns the IMAP connection' do
+    it "returns the IMAP connection" do
       expect(@result).to eq(imap)
     end
 
-    include_examples 'connects to IMAP'
+    include_examples "connects to IMAP"
   end
 
-  context '#folders' do
-    let(:imap_folders) { ['imap_folder'] }
+  context "#folders" do
+    let(:imap_folders) { ["imap_folder"] }
 
     before { allow(imap).to receive(:list).and_return(imap_folders) }
 
-    it 'returns the list of folders' do
+    it "returns the list of folders" do
       expect(subject.folders).to eq(imap_folders)
     end
   end
 
-  context '#status' do
-    let(:folder) { double('folder', :uids => [remote_uid]) }
-    let(:local_uid) { 'local_uid' }
-    let(:serializer) { double('serializer', :uids => [local_uid]) }
-    let(:remote_uid) { 'remote_uid' }
+  context "#status" do
+    let(:folder) { double("folder", uids: [remote_uid]) }
+    let(:local_uid) { "local_uid" }
+    let(:serializer) { double("serializer", uids: [local_uid]) }
+    let(:remote_uid) { "remote_uid" }
 
     before do
       allow(Imap::Backup::Account::Folder).to receive(:new).and_return(folder)
       allow(Imap::Backup::Serializer::Directory).to receive(:new).and_return(serializer)
     end
 
-    it 'should return the names of folders' do
+    it "should return the names of folders" do
       expect(subject.status[0][:name]).to eq(self.class.backup_folder)
     end
 
-    it 'returns local message uids' do
+    it "returns local message uids" do
       expect(subject.status[0][:local]).to eq([local_uid])
     end
 
-    it 'should retrieve the available uids' do
+    it "should retrieve the available uids" do
       expect(subject.status[0][:remote]).to eq([remote_uid])
     end
   end
 
-  context '#run_backup' do
-    let(:folder) { double('folder', name: 'folder') }
-    let(:serializer) { double('serializer') }
-    let(:downloader) { double(Imap::Backup::Downloader, :run => nil) }
+  context "#run_backup" do
+    let(:folder) { double("folder", name: "folder") }
+    let(:serializer) { double("serializer") }
+    let(:downloader) { double(Imap::Backup::Downloader, run: nil) }
 
     before do
       allow(Imap::Backup::Downloader).
         to receive(:new).with(folder, serializer) { downloader }
     end
 
-    context 'with supplied backup_folders' do
+    context "with supplied backup_folders" do
       before do
         allow(Imap::Backup::Account::Folder).to receive(:new).
           with(subject, self.class.backup_folder).and_return(folder)
@@ -122,37 +121,37 @@ describe Imap::Backup::Account::Connection do
 
       before { subject.run_backup }
 
-      it 'runs the downloader' do
+      it "runs the downloader" do
         expect(downloader).to have_received(:run)
       end
     end
 
-    context 'without supplied backup_folders' do
-      let(:imap_folders) { [double(:name => 'foo')] }
+    context "without supplied backup_folders" do
+      let(:imap_folders) { [double(name: "foo")] }
 
       before do
         allow(Imap::Backup::Account::Folder).to receive(:new).
-          with(subject, 'foo').and_return(folder)
+          with(subject, "foo").and_return(folder)
         allow(Imap::Backup::Serializer::Mbox).to receive(:new).
-          with(local_path, 'foo').and_return(serializer)
+          with(local_path, "foo").and_return(serializer)
       end
 
-      context 'when supplied backup_folders is nil' do
+      context "when supplied backup_folders is nil" do
         let(:backup_folders) { nil }
 
         before { subject.run_backup }
 
-        it 'runs the downloader for each folder' do
+        it "runs the downloader for each folder" do
           expect(downloader).to have_received(:run).exactly(:once)
         end
       end
 
-      context 'when supplied backup_folders is an empty list' do
+      context "when supplied backup_folders is an empty list" do
         let(:backup_folders) { [] }
 
         before { subject.run_backup }
 
-        it 'runs the downloader for each folder' do
+        it "runs the downloader for each folder" do
           expect(downloader).to have_received(:run).exactly(:once)
         end
       end
@@ -161,20 +160,20 @@ describe Imap::Backup::Account::Connection do
         let(:backup_folders) { nil }
         let(:imap_folders) { nil }
 
-        it 'does not fail' do
+        it "does not fail" do
           expect { subject.run_backup }.to_not raise_error
         end
       end
     end
   end
 
-  context '#disconnect' do
+  context "#disconnect" do
     before { subject.disconnect }
 
-    it 'disconnects from the server' do
+    it "disconnects from the server" do
       expect(imap).to have_received(:disconnect)
     end
 
-    include_examples 'connects to IMAP'
+    include_examples "connects to IMAP"
   end
 end

data/spec/unit/account/folder_spec.rb

@@ -1,50 +1,49 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Account::Folder do
-  let(:imap) { double('Net::IMAP', :examine => nil) }
-  let(:connection) { double('Imap::Backup::Account::Connection', :imap => imap) }
-  let(:missing_mailbox_data) { double('Data', :text => 'Unknown Mailbox: my_folder') }
-  let(:missing_mailbox_response) { double('Response', :data => missing_mailbox_data) }
+  let(:imap) { double("Net::IMAP", examine: nil) }
+  let(:connection) { double("Imap::Backup::Account::Connection", imap: imap) }
+  let(:missing_mailbox_data) { double("Data", text: "Unknown Mailbox: my_folder") }
+  let(:missing_mailbox_response) { double("Response", data: missing_mailbox_data) }
   let(:missing_mailbox_error) { Net::IMAP::NoResponseError.new(missing_mailbox_response) }
 
-  subject { described_class.new(connection, 'my_folder') }
+  subject { described_class.new(connection, "my_folder") }
 
-  context '#uids' do
+  context "#uids" do
     let(:uids) { [5678, 123] }
 
     before { allow(imap).to receive(:uid_search).and_return(uids) }
 
-    it 'lists available messages' do
+    it "lists available messages" do
       expect(subject.uids).to eq(uids.reverse)
     end
 
-    context 'with missing mailboxes' do
+    context "with missing mailboxes" do
       before { allow(imap).to receive(:examine).and_raise(missing_mailbox_error) }
 
-      it 'returns an empty array' do
+      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) }
-    let(:attributes) { {'RFC822' => message_body, 'other' => 'xxx'} }
+  context "#fetch" do
+    let(:message_body) { double("the body", force_encoding: nil) }
+    let(:attributes) { {"RFC822" => message_body, "other" => "xxx"} }
     let(:fetch_data_item) do
       instance_double(Net::IMAP::FetchData, attr: attributes)
     end
 
     before { allow(imap).to receive(:uid_fetch) { [fetch_data_item] } }
 
-    it 'returns the message' do
+    it "returns the message" do
       expect(subject.fetch(123)).to eq(attributes)
     end
 
     context "if the server responds with nothing" do
       before { allow(imap).to receive(:uid_fetch) { nil } }
 
-      it 'is nil' do
+      it "is nil" do
         expect(subject.fetch(123)).to be_nil
       end
     end
@@ -52,15 +51,15 @@ describe Imap::Backup::Account::Folder do
     context "if the mailbox doesn't exist" do
       before { allow(imap).to receive(:examine).and_raise(missing_mailbox_error) }
 
-      it 'is nil' do
+      it "is nil" do
         expect(subject.fetch(123)).to be_nil
       end
     end
 
-    it 'sets the encoding on the message' do
+    it "sets the encoding on the message" do
       subject.fetch(123)
 
-      expect(message_body).to have_received(:force_encoding).with('utf-8')
+      expect(message_body).to have_received(:force_encoding).with("utf-8")
     end
   end
 end

data/spec/unit/configuration/account_spec.rb

@@ -1,5 +1,4 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Configuration::Account do
   class MockHighlineMenu
@@ -19,10 +18,10 @@ describe Imap::Backup::Configuration::Account do
     end
   end
 
-  context '#initialize' do
-    let(:store) { 'store' }
-    let(:account) { 'account' }
-    let(:highline) { 'highline' }
+  context "#initialize" do
+    let(:store) { "store" }
+    let(:account) { "account" }
+    let(:highline) { "highline" }
 
     subject { described_class.new(store, account, highline) }
 
@@ -33,32 +32,32 @@ describe Imap::Backup::Configuration::Account do
     end
   end
 
-  context '#run' do
-    let(:highline) { double('Highline') }
+  context "#run" do
+    let(:highline) { double("Highline") }
     let(:menu) { MockHighlineMenu.new }
-    let(:store) { double('Imap::Backup::Configuration::Store', :accounts => accounts) }
+    let(:store) { double("Imap::Backup::Configuration::Store", accounts: accounts) }
     let(:accounts) { [account, account1] }
     let(:account) do
       {
-        :username => existing_email,
-        :server => existing_server,
-        :local_path => '/backup/path',
-        :folders => [{:name => 'my_folder'}],
-        :password => existing_password,
+        username: existing_email,
+        server: existing_server,
+        local_path: "/backup/path",
+        folders: [{name: "my_folder"}],
+        password: existing_password,
       }
     end
     let(:account1) do
       {
-        :username => other_email,
-        :local_path => other_existing_path,
+        username: other_email,
+        local_path: other_existing_path,
       }
     end
-    let(:existing_email) { 'user@example.com' }
-    let(:new_email) { 'foo@example.com' }
-    let(:existing_server) { 'imap.example.com' }
-    let(:existing_password) { 'password' }
-    let(:other_email) { 'other@example.com' }
-    let(:other_existing_path) { '/other/existing/path' }
+    let(:existing_email) { "user@example.com" }
+    let(:new_email) { "foo@example.com" }
+    let(:existing_server) { "imap.example.com" }
+    let(:existing_password) { "password" }
+    let(:other_email) { "other@example.com" }
+    let(:other_existing_path) { "/other/existing/path" }
 
     before do
       allow(subject).to receive(:system).and_return(nil)
@@ -71,31 +70,31 @@ describe Imap::Backup::Configuration::Account do
 
     subject { described_class.new(store, account, highline) }
 
-    context 'preparation' do
+    context "preparation" do
       before { subject.run }
 
-      it 'clears the screen' do
-        expect(subject).to have_received(:system).with('clear')
+      it "clears the screen" do
+        expect(subject).to have_received(:system).with("clear")
       end
 
-      context 'menu' do
-        it 'shows the menu' do
+      context "menu" do
+        it "shows the menu" do
           expect(highline).to have_received(:choose)
         end
       end
     end
 
-    context 'menu' do
+    context "menu" do
       [
-        'modify email',
-        'modify password',
-        'modify server',
-        'modify backup path',
-        'choose backup folders',
-        'test connection',
-        'delete',
-        'return to main menu',
-        'quit', # TODO: quit is hidden
+        "modify email",
+        "modify password",
+        "modify server",
+        "modify backup path",
+        "choose backup folders",
+        "test connection",
+        "delete",
+        "return to main menu",
+        "quit", # TODO: quit is hidden
       ].each do |item|
         before { subject.run }
 
@@ -105,13 +104,13 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context 'account details' do
+    context "account details" do
       [
-        ['email', /email:\s+user@example.com/],
-        ['server', /server:\s+imap.example.com/],
-        ['password', /password:\s+x+/],
-        ['path', %r(path:\s+/backup/path)],
-        ['folders', /folders:\s+my_folder/],
+        ["email", /email:\s+user@example.com/],
+        ["server", /server:\s+imap.example.com/],
+        ["password", /password:\s+x+/],
+        ["path", %r(path:\s+/backup/path)],
+        ["folders", /folders:\s+my_folder/]
       ].each do |attribute, value|
         before { subject.run }
 
@@ -120,44 +119,44 @@ describe Imap::Backup::Configuration::Account do
         end
       end
 
-      context 'with no password' do
-        let(:existing_password) { '' }
+      context "with no password" do
+        let(:existing_password) { "" }
 
         before { subject.run }
 
-        it 'indicates that a password is not set' do
-          expect(menu.header).to include('password: (unset)')
+        it "indicates that a password is not set" do
+          expect(menu.header).to include("password: (unset)")
         end
       end
     end
 
-    context 'email' do
+    context "email" do
       before do
         allow(Imap::Backup::Configuration::Asker).to receive(:email).and_return(new_email)
         subject.run
-        menu.choices['modify email'].call
+        menu.choices["modify email"].call
       end
 
-      context 'if the server is blank' do
+      context "if the server is blank" do
         [
-          ['GMail', 'foo@gmail.com', 'imap.gmail.com'],
-          ['Fastmail', 'bar@fastmail.fm', 'mail.messagingengine.com'],
+          ["GMail", "foo@gmail.com", "imap.gmail.com"],
+          ["Fastmail", "bar@fastmail.fm", "mail.messagingengine.com"]
         ].each do |service, email, expected|
           context service do
             let(:new_email) { email }
 
-            context 'with nil' do
+            context "with nil" do
               let(:existing_server) { nil }
 
-              it 'sets a default server' do
+              it "sets a default server" do
                 expect(account[:server]).to eq(expected)
               end
             end
 
-            context 'with an empty string' do
-              let(:existing_server) { '' }
+            context "with an empty string" do
+              let(:existing_server) { "" }
 
-              it 'sets a default server' do
+              it "sets a default server" do
                 expect(account[:server]).to eq(expected)
               end
             end
@@ -165,19 +164,19 @@ describe Imap::Backup::Configuration::Account do
         end
       end
 
-      context 'the email is new' do
-        it 'modifies the email address' do
+      context "the email is new" do
+        it "modifies the email address" do
           expect(account[:username]).to eq(new_email)
         end
 
-        include_examples 'it flags the account as modified'
+        include_examples "it flags the account as modified"
       end
 
-      context 'the email already exists' do
+      context "the email already exists" do
         let(:new_email) { other_email }
 
-        it 'indicates the error' do
-          expect(subject).to have_received(:puts).with('There is already an account set up with that email address')
+        it "indicates the error" do
+          expect(subject).to have_received(:puts).with("There is already an account set up with that email address")
         end
 
         it "doesn't set the email" do
@@ -188,27 +187,27 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context 'password' do
-      let(:new_password) { 'new_password' }
+    context "password" do
+      let(:new_password) { "new_password" }
 
       before do
         allow(Imap::Backup::Configuration::Asker).to receive(:password).and_return(new_password)
         subject.run
-        menu.choices['modify password'].call
+        menu.choices["modify password"].call
       end
 
-      context 'if the user enters a password' do
-        it 'updates the password' do
+      context "if the user enters a password" do
+        it "updates the password" do
           expect(account[:password]).to eq(new_password)
         end
 
-        include_examples 'it flags the account as modified'
+        include_examples "it flags the account as modified"
       end
 
-      context 'if the user cancels' do
+      context "if the user cancels" do
         let(:new_password) { nil }
 
-        it 'does nothing' do
+        it "does nothing" do
           expect(account[:password]).to eq(existing_password)
         end
 
@@ -216,27 +215,27 @@ describe Imap::Backup::Configuration::Account do
       end
     end
 
-    context 'server' do
-      let(:server) { 'server' }
+    context "server" do
+      let(:server) { "server" }
 
       before do
-        allow(highline).to receive(:ask).with('server: ').and_return(server)
+        allow(highline).to receive(:ask).with("server: ").and_return(server)
       end
 
       before do
         subject.run
-        menu.choices['modify server'].call
+        menu.choices["modify server"].call
       end
 
-      it 'updates the server' do
+      it "updates the server" do
         expect(account[:server]).to eq(server)
       end
 
-      include_examples 'it flags the account as modified'
+      include_examples "it flags the account as modified"
     end
 
-    context 'backup_path' do
-      let(:new_backup_path) { '/new/path' }
+    context "backup_path" do
+      let(:new_backup_path) { "/new/path" }
 
       before do
         @validator = nil
@@ -245,67 +244,67 @@ describe Imap::Backup::Configuration::Account do
           new_backup_path
         end
         subject.run
-        menu.choices['modify backup path'].call
+        menu.choices["modify backup path"].call
       end
 
-      it 'updates the path' do
+      it "updates the path" do
         expect(account[:local_path]).to eq(new_backup_path)
       end
 
-      it 'validates that the path is not used by other backups' do
+      it "validates that the path is not used by other backups" do
         expect(@validator.call(other_existing_path)).to be_falsey
       end
 
-      include_examples 'it flags the account as modified'
+      include_examples "it flags the account as modified"
     end
 
-    context 'folders' do
-      let(:chooser) { double(:run => nil) }
+    context "folders" do
+      let(:chooser) { double(run: nil) }
 
       before do
         allow(Imap::Backup::Configuration::FolderChooser).to receive(:new).and_return(chooser)
         subject.run
-        menu.choices['choose backup folders'].call
+        menu.choices["choose backup folders"].call
       end
 
-      it 'edits folders' do
+      it "edits folders" do
         expect(chooser).to have_received(:run)
       end
     end
 
-    context 'connection test' do
+    context "connection test" do
       before do
-        allow(Imap::Backup::Configuration::ConnectionTester).to receive(:test).and_return('All fine')
+        allow(Imap::Backup::Configuration::ConnectionTester).to receive(:test).and_return("All fine")
         allow(highline).to receive(:ask)
         subject.run
-        menu.choices['test connection'].call
+        menu.choices["test connection"].call
       end
 
-      it 'tests the connection' do
+      it "tests the connection" do
         expect(Imap::Backup::Configuration::ConnectionTester).to have_received(:test).with(account)
       end
     end
 
-    context 'deletion' do
+    context "deletion" do
       let(:confirmed) { true }
 
       before do
         allow(highline).to receive(:agree).and_return(confirmed)
         subject.run
         catch :done do
-          menu.choices['delete'].call
+          menu.choices["delete"].call
         end
       end
 
-      it 'asks for confirmation' do
+      it "asks for confirmation" do
         expect(highline).to have_received(:agree)
       end
 
-      context 'when the user confirms deletion' do
-        include_examples 'it flags the account to be deleted'
+      context "when the user confirms deletion" do
+        include_examples "it flags the account to be deleted"
       end
 
-      context 'without confirmation' do
+      context "without confirmation" do
         let(:confirmed) { false }
 
         include_examples "it doesn't flag the account to be deleted"