imap-backup 1.2.2 → 1.2.3

data/spec/unit/configuration/asker_spec.rb

@@ -1,12 +1,11 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 module Imap::Backup
   describe Configuration::Asker do
     let(:highline) { double }
     let(:query) do
       double(
-        'Query',
+        "Query",
         :default= => nil,
         :readline= => nil,
         :validate= => nil,
@@ -14,7 +13,7 @@ module Imap::Backup
         :echo= => nil
       )
     end
-    let(:answer) { 'foo' }
+    let(:answer) { "foo" }
 
     before do
       allow(Configuration::Setup).to receive(:highline).and_return(highline)
@@ -27,63 +26,63 @@ module Imap::Backup
     subject { described_class.new(highline) }
 
     [
-      [:email, [], 'email address'],
-      [:password, [], 'password'],
-      [:backup_path, ['x', 'y'], 'backup directory'],
+      [:email, [], "email address"],
+      [:password, [], "password"],
+      [:backup_path, ["x", "y"], "backup directory"]
     ].each do |method, params, prompt|
       context ".#{method}" do
-        it 'asks for input' do
+        it "asks for input" do
           described_class.send(method, *params)
 
           expect(highline).to have_received(:ask).with("#{prompt}: ")
         end
 
-        it 'returns the answer' do
+        it "returns the answer" do
           expect(described_class.send(method, *params)).to eq(answer)
         end
       end
     end
 
-    context '#initialize' do
-      it 'requires 1 parameter' do
+    context "#initialize" do
+      it "requires 1 parameter" do
         expect do
           described_class.new
         end.to raise_error(ArgumentError, /wrong number/)
       end
 
-      it 'expects a higline' do
+      it "expects a higline" do
         expect(subject.highline).to eq(highline)
       end
     end
 
-    context '#email' do
-      let(:email) { 'email@example.com' }
+    context "#email" do
+      let(:email) { "email@example.com" }
       let(:answer) { email }
 
       before do
         @result = subject.email
       end
 
-      it 'asks for an email' do
+      it "asks for an email" do
         expect(highline).to have_received(:ask).with(/email/)
       end
 
-      it 'returns the address' do
+      it "returns the address" do
         expect(@result).to eq(email)
       end
     end
 
-    context '#password' do
-      let(:password1) { 'password' }
-      let(:password2) { 'password' }
+    context "#password" do
+      let(:password1) { "password" }
+      let(:password2) { "password" }
       let(:answers) { [answer1, answer2] }
       let(:answer1) { true }
       let(:answer2) { 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)
+        allow(highline).to receive(:ask).with("password: ").and_return(password1)
+        allow(highline).to receive(:ask).with("repeat password: ").and_return(password2)
         allow(highline).to receive(:agree) do
           answer = answers[@i]
           @i += 1
@@ -92,29 +91,29 @@ module Imap::Backup
         @result = subject.password
       end
 
-      it 'asks for a password' do
-        expect(highline).to have_received(:ask).with('password: ')
+      it "asks for a password" do
+        expect(highline).to have_received(:ask).with("password: ")
       end
 
-      it 'asks for confirmation' do
-        expect(highline).to have_received(:ask).with('repeat password: ')
+      it "asks for confirmation" do
+        expect(highline).to have_received(:ask).with("repeat password: ")
       end
 
-      it 'returns the password' do
+      it "returns the password" do
         expect(@result).to eq(password1)
       end
 
-      context 'different answers' do
-        let(:password2) { 'secret' }
+      context "different answers" do
+        let(:password2) { "secret" }
 
-        it 'asks to continue' do
+        it "asks to continue" do
           expect(highline).to have_received(:agree).at_least(1).times.with(/Continue\?/)
         end
       end
     end
 
-    context '#backup_path' do
-      let(:path) { '/path' }
+    context "#backup_path" do
+      let(:path) { "/path" }
       let(:answer) { path }
 
       before do
@@ -122,14 +121,14 @@ module Imap::Backup
           b.call query
           path
         end
-        @result = subject.backup_path('', //)
+        @result = subject.backup_path("", //)
       end
 
-      it 'asks for a directory' do
+      it "asks for a directory" do
         expect(highline).to have_received(:ask).with(/directory/)
       end
 
-      it 'returns the path' do
+      it "returns the path" do
         expect(@result).to eq(path)
       end
     end

data/spec/unit/configuration/connection_tester_spec.rb

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

data/spec/unit/configuration/folder_chooser_spec.rb

@@ -1,12 +1,11 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Configuration::FolderChooser do
   include HighLineTestHelpers
 
-  context '#run' do
-    let(:connection) { double('Imap::Backup::Account::Connection', :folders => remote_folders) }
-    let(:account) { {:folders => []} }
+  context "#run" do
+    let(:connection) { double("Imap::Backup::Account::Connection", folders: remote_folders) }
+    let(:account) { {folders: []} }
     let(:remote_folders) { [] }
 
     subject { described_class.new(account) }
@@ -18,68 +17,68 @@ describe Imap::Backup::Configuration::FolderChooser do
       allow(Imap::Backup.logger).to receive(:warn)
     end
 
-    context 'display' do
+    context "display" 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
 
-      it 'should show the menu' do
+      it "should show the menu" do
         expect(@output.string).to match %r{Add/remove folders}
       end
     end
 
-    context 'folder listing' do
-      let(:account) { {:folders => [{:name => 'my_folder'}]} }
+    context "folder listing" do
+      let(:account) { {folders: [{name: "my_folder"}]} }
       let(:remote_folders) do
-        folder1 = double('folder', :name => 'my_folder')       # this one is already backed up
-        folder2 = double('folder', :name => 'another_folder')
+        folder1 = double("folder", name: "my_folder") # this one is already backed up
+        folder2 = double("folder", name: "another_folder")
         [folder1, folder2]
       end
 
-      context 'display' do
+      context "display" do
         before { subject.run }
 
-        it 'shows folders which are being backed up' do
-          expect(@output.string).to include('+ my_folder')
+        it "shows folders which are being backed up" do
+          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')
+        it "shows folders which are not being backed up" do
+          expect(@output.string).to include("- another_folder")
         end
       end
 
-      context 'adding folders' do
+      context "adding folders" do
         before do
           allow(@input).to receive(:gets).and_return("2\n", "q\n")
 
           subject.run
         end
 
-        specify 'are added to the account' do
-          expect(account[:folders]).to include({:name => 'another_folder'})
+        specify "are added to the account" do
+          expect(account[:folders]).to include({name: "another_folder"})
         end
 
-        include_examples 'it flags the account as modified'
+        include_examples "it flags the account as modified"
       end
 
-      context 'removing folders' do
+      context "removing folders" do
         before do
           allow(@input).to receive(:gets).and_return("1\n", "q\n")
 
           subject.run
         end
 
-        specify 'are removed from the account' do
-          expect(account[:folders]).to_not include({:name => 'my_folder'})
+        specify "are removed from the account" do
+          expect(account[:folders]).to_not include({name: "my_folder"})
         end
 
-        include_examples 'it flags the account as modified'
+        include_examples "it flags the account as modified"
       end
     end
 
-    context 'when folders are not available' do
+    context "when folders are not available" do
       let(:remote_folders) { nil }
 
       before do
@@ -87,24 +86,24 @@ describe Imap::Backup::Configuration::FolderChooser do
         subject.run
       end
 
-      it 'asks to press a key' do
-        expect(Imap::Backup::Configuration::Setup.highline).to have_received(:ask).with('Press a key ')
+      it "asks to press a key" do
+        expect(Imap::Backup::Configuration::Setup.highline).to have_received(:ask).with("Press a key ")
       end
     end
 
-    context 'with connection errors' do
+    context "with connection errors" do
       before do
-        allow(Imap::Backup::Account::Connection).to receive(:new).with(account).and_raise('error')
+        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
       end
 
-      it 'prints an error message' do
-        expect(Imap::Backup.logger).to have_received(:warn).with('Connection failed')
+      it "prints an error message" do
+        expect(Imap::Backup.logger).to have_received(:warn).with("Connection failed")
       end
 
-      it 'asks to continue' do
-        expect(Imap::Backup::Configuration::Setup.highline).to have_received(:ask).with('Press a key ')
+      it "asks to continue" do
+        expect(Imap::Backup::Configuration::Setup.highline).to have_received(:ask).with("Press a key ")
       end
     end
   end

data/spec/unit/configuration/list_spec.rb

@@ -1,19 +1,18 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Configuration::List do
   let(:accounts) do
     [
-      {:username => 'a1@example.com'},
-      {:username => 'a2@example.com'},
+      {username: "a1@example.com"},
+      {username: "a2@example.com"}
     ]
   end
   let(:store) do
-    double('Imap::Backup::Configuration::Store', accounts: accounts)
+    double("Imap::Backup::Configuration::Store", accounts: accounts)
   end
   let(:exists) { true }
-  let(:connection1) { double('Imap::Backup::Account::Connection', :disconnect => nil) }
-  let(:connection2) { double('Imap::Backup::Account::Connection', :disconnect => nil) }
+  let(:connection1) { double("Imap::Backup::Account::Connection", disconnect: nil) }
+  let(:connection2) { double("Imap::Backup::Account::Connection", disconnect: nil) }
 
   before do
     allow(Imap::Backup::Configuration::Store).to receive(:new).and_return(store)
@@ -24,10 +23,10 @@ describe Imap::Backup::Configuration::List do
 
   subject { described_class.new }
 
-  context '#initialize' do
+  context "#initialize" do
   end
 
-  context '#each_connection' do
+  context "#each_connection" do
     specify "calls the block with each account's connection" do
       connections = []
 
@@ -36,10 +35,10 @@ describe Imap::Backup::Configuration::List do
       expect(connections).to eq([connection1, connection2])
     end
 
-    context 'with account parameter' do
-      subject { described_class.new(['a2@example.com']) }
+    context "with account parameter" do
+      subject { described_class.new(["a2@example.com"]) }
 
-      it 'should only create requested accounts' do
+      it "should only create requested accounts" do
         connections = []
 
         subject.each_connection { |a| connections << a }
@@ -48,10 +47,10 @@ describe Imap::Backup::Configuration::List do
       end
     end
 
-    context 'when the configuration file is missing' do
+    context "when the configuration file is missing" do
       let(:exists) { false }
 
-      it 'fails' do
+      it "fails" do
         expect {
           subject.each_connection {}
         }.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)

data/spec/unit/configuration/setup_spec.rb

@@ -1,25 +1,24 @@
-# encoding: utf-8
-require 'spec_helper'
+require "spec_helper"
 
 describe Imap::Backup::Configuration::Setup do
   include HighLineTestHelpers
 
-  context '#initialize' do
-    context 'without a config file' do
-      it 'works' do
+  context "#initialize" do
+    context "without a config file" do
+      it "works" do
         described_class.new
       end
     end
   end
 
-  context '#run' do
-    let(:normal) { {:username => 'account@example.com'} }
+  context "#run" do
+    let(:normal) { {username: "account@example.com"} }
     let(:accounts) { [normal] }
     let(:store) do
       double(
-        'Imap::Backup::Configuration::Store',
+        "Imap::Backup::Configuration::Store",
         :accounts => accounts,
-        :path => '/base/path',
+        :path => "/base/path",
         :save => nil,
         :debug? => debug,
         :debug= => nil,
@@ -40,7 +39,7 @@ describe Imap::Backup::Configuration::Setup do
 
     subject { described_class.new }
 
-    context 'main menu' do
+    context "main menu" do
       before { subject.run }
 
       %w(add\ account save\ and\ exit exit\ without\ saving).each do |choice|
@@ -50,64 +49,64 @@ describe Imap::Backup::Configuration::Setup do
       end
     end
 
-    it 'clears the screen' do
+    it "clears the screen" do
       subject.run
 
-      expect(subject).to have_received(:system).with('clear')
+      expect(subject).to have_received(:system).with("clear")
     end
 
-    it 'updates logging status' do
+    it "updates logging status" do
       subject.run
 
       expect(Imap::Backup).to have_received(:setup_logging)
     end
 
-    context 'listing' do
+    context "listing" do
       let(:accounts) { [normal, modified, deleted] }
-      let(:modified) { {:username => 'modified@example.com', :modified => true} }
-      let(:deleted) { {:username => 'deleted@example.com', :delete => true} }
+      let(:modified) { {username: "modified@example.com", modified: true} }
+      let(:deleted) { {username: "deleted@example.com", delete: true} }
 
       before { subject.run }
 
-      context 'normal accounts' do
-        it 'are listed' do
+      context "normal accounts" do
+        it "are listed" do
           expect(@output.string).to match /account@example.com/
         end
       end
 
-      context 'modified accounts' do
-        it 'are flagged' do
+      context "modified accounts" do
+        it "are flagged" do
           expect(@output.string).to match /modified@example.com \*/
         end
       end
 
-      context 'deleted accounts' do
-        it 'are hidden' do
+      context "deleted accounts" do
+        it "are hidden" do
           expect(@output.string).to_not match /delete@example.com/
         end
       end
     end
 
-    context 'adding accounts' do
+    context "adding accounts" do
       let(:blank_account) do
         {
-          :username => "new@example.com",
-          :password => "",
-          :local_path => "/base/path/new_example.com",
-          :folders => []
+          username: "new@example.com",
+          password: "",
+          local_path: "/base/path/new_example.com",
+          folders: []
         }
       end
-      let(:account) { double('Imap::Backup::Configuration::Account', :run => nil) }
+      let(:account) { double("Imap::Backup::Configuration::Account", run: nil) }
 
       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')
+        allow(Imap::Backup::Configuration::Asker).to receive(:email).with(no_args).and_return("new@example.com")
         allow(Imap::Backup::Configuration::Account).to receive(:new).with(store, blank_account, anything).and_return(account)
 
         subject.run
       end
 
-      it 'adds account data' do
+      it "adds account data" do
         expect(accounts[1]).to eq(blank_account)
       end
 
@@ -116,29 +115,29 @@ describe Imap::Backup::Configuration::Setup do
       end
     end
 
-    context 'logging' do
-      context 'when debug logging is disabled' do
+    context "logging" 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
-          expect(@output.string).to include('start logging')
+        it "shows a menu item" do
+          expect(@output.string).to include("start logging")
         end
 
-        context 'when selected' do
-          it 'sets the debug flag' do
+        context "when selected" do
+          it "sets the debug flag" do
             expect(store).to have_received(:debug=).with(true)
           end
 
-          it 'updates logging status' do
+          it "updates logging status" do
             expect(Imap::Backup).to have_received(:setup_logging).twice
           end
         end
       end
 
-      context 'when debug logging is enabled' do
+      context "when debug logging is enabled" do
         let(:debug) { true }
 
         before do
@@ -146,20 +145,20 @@ describe Imap::Backup::Configuration::Setup do
           subject.run
         end
 
-        it 'shows a menu item' do
-          expect(@output.string).to include('stop logging')
+        it "shows a menu item" do
+          expect(@output.string).to include("stop logging")
         end
 
-        context 'when selected' do
+        context "when selected" do
           before do
             allow(@input).to receive(:gets).and_return("stop\n", "exit\n")
           end
 
-          it 'unsets the debug flag' do
+          it "unsets the debug flag" do
             expect(store).to have_received(:debug=).with(false)
           end
 
-          it 'updates logging status' do
+          it "updates logging status" do
             expect(Imap::Backup).to have_received(:setup_logging).twice
           end
         end
@@ -172,11 +171,11 @@ describe Imap::Backup::Configuration::Setup do
         subject.run
       end
 
-      it 'exits' do
+      it "exits" do
         # N.B. this will hang forever if save does not cause an exit
       end
 
-      it 'saves the configuration' do
+      it "saves the configuration" do
         expect(store).to have_received(:save)
       end
     end
@@ -188,11 +187,11 @@ describe Imap::Backup::Configuration::Setup do
         subject.run
       end
 
-      it 'exits' do
+      it "exits" do
         # N.B. this will hang forever if quit does not cause an exit
       end
 
-      context 'when the configuration is modified' do
+      context "when the configuration is modified" do
         let(:modified) { true }
 
         it "doesn't save the configuration" do