spec/unit/account/connection_spec.rb in imap-backup-1.2.2 vs spec/unit/account/connection_spec.rb in imap-backup-1.2.3

@@ -1,180 +1,179 @@
-# 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) { '[e-mail]' }
+  let(:username) { "[e-mail]" }
 
   before do
     allow(Net::IMAP).to receive(:new).and_return(imap)
     allow(Imap::Backup::Utils).to receive(:make_folder)
   end
 
   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, '[e-mail]'],
-      [:local_path, 'local_path'],
-      [:backup_folders, [folder_config]],
+      [:username, "[e-mail]"],
+      [: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)
         allow(Imap::Backup::Serializer::Mbox).to receive(:new).
           with(local_path, self.class.backup_folder).and_return(serializer)
       end
 
       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
 
       context "when the imap server doesn't return folders" 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