imap-backup 1.0.9 → 1.0.10

data/lib/imap/backup/utils.rb

@@ -1,40 +1,33 @@
 # encoding: utf-8
 require 'fileutils'
 
-module Imap
-  module Backup
-    module Utils
-      def self.check_permissions(filename, limit)
-        actual = stat(filename)
-        mask   = ~limit & 0777
-        if actual & mask != 0
-          raise "Permissions on '#{filename}' should be #{oct(limit)}, not #{oct(actual)}" 
-        end
-      end
-
-      def self.stat(filename)
-        return nil unless File.exist?(filename)
-
-        stat = File.stat(filename)
-        stat.mode & 0777
+module Imap::Backup
+  module Utils
+    def self.check_permissions(filename, limit)
+      actual = stat(filename)
+      return nil if actual.nil?
+      mask = ~limit & 0777
+      if actual & mask != 0
+        raise format("Permissions on '%s' should be 0%o, not 0%o", filename, limit, actual)
       end
+    end
 
-      def self.make_folder(base_path, path, permissions)
-        parts = path.split('/')
-        return if parts.size == 0
-        full_path = File.join(base_path, path)
-        FileUtils.mkdir_p full_path
-        path = base_path
-        parts.each do |part|
-          path = File.join(path, part)
-          FileUtils.chmod permissions, path
-        end
-      end
+    def self.stat(filename)
+      return nil unless File.exist?(filename)
 
-      private
+      stat = File.stat(filename)
+      stat.mode & 0777
+    end
 
-      def self.oct(permissions)
-        "0%o" % permissions
+    def self.make_folder(base_path, path, permissions)
+      parts = path.split('/')
+      return if parts.size == 0
+      full_path = File.join(base_path, path)
+      FileUtils.mkdir_p full_path
+      path = base_path
+      parts.each do |part|
+        path = File.join(path, part)
+        FileUtils.chmod permissions, path
       end
     end
   end

data/lib/imap/backup/version.rb

@@ -1,8 +1,8 @@
-module Imap
-  module Backup
-    MAJOR    = 1
-    MINOR    = 0
-    REVISION = 9
-    VERSION  = [MAJOR, MINOR, REVISION].map(&:to_s).join('.')
-  end
+module Imap; end
+
+module Imap::Backup
+  MAJOR    = 1
+  MINOR    = 0
+  REVISION = 10
+  VERSION  = [MAJOR, MINOR, REVISION].map(&:to_s).join('.')
 end

data/spec/spec_helper.rb

@@ -1,37 +1,20 @@
 require 'rspec'
+spec_path = File.dirname(__FILE__)
+$LOAD_PATH << File.expand_path('../lib', spec_path)
+
+support_glob = File.join(spec_path, 'support', '**', '*.rb')
+Dir[support_glob].each { |f| require f }
 
 if RUBY_VERSION < '1.9'
   require 'rspec/autorun'
 else
   require 'simplecov'
-  if defined?(GATHER_RSPEC_COVERAGE)
-    SimpleCov.start do
-      add_filter "/spec/"
-      add_filter "/vendor/"
-    end
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/vendor/'
   end
 end
 
-require File.expand_path(File.dirname(__FILE__) + '/../lib/imap/backup')
-
-module HighLineTestHelpers
-  def prepare_highline
-    @input  = stub('stdin', :eof? => false)
-    # default gets stub
-    @input.stub!(:gets).with().and_return("q\n")
-    @output = StringIO.new
-    Imap::Backup::Configuration::Setup.highline = HighLine.new(@input, @output)
-    [@input, @output]
-  end
-end
+require 'imap/backup'
 
-module InputOutputTestHelpers
-  def capturing_output
-    output = StringIO.new
-    $stdout = output
-    yield
-    output.string
-  ensure
-    $stdout = STDOUT
-  end
-end
+silence_logging

data/spec/support/higline_test_helpers.rb

@@ -0,0 +1,8 @@
+module HighLineTestHelpers
+  def prepare_highline
+    @input = double('stdin', :eof? => false, :gets => "q\n")
+    @output = StringIO.new
+    Imap::Backup::Configuration::Setup.highline = HighLine.new(@input, @output)
+    [@input, @output]
+  end
+end

data/spec/support/silence_logging.rb

@@ -0,0 +1,7 @@
+def silence_logging
+  RSpec.configure do |config|
+    config.before(:suite) do
+      Imap::Backup.logger.level = Logger::UNKNOWN
+    end
+  end
+end

data/spec/unit/account/connection_spec.rb

@@ -21,7 +21,7 @@ describe Imap::Backup::Account::Connection do
     allow(Net::IMAP).to receive(:new).and_return(imap)
   end
 
-  subject { Imap::Backup::Account::Connection.new(options) }
+  subject { described_class.new(options) }
 
   shared_examples 'connects to IMAP' do |options|
     options ||= {}

data/spec/unit/account/folder_spec.rb

@@ -2,74 +2,55 @@
 require 'spec_helper'
 
 describe Imap::Backup::Account::Folder do
-  include InputOutputTestHelpers
-
-  let(:imap) { stub('Net::IMAP') }
-  let(:connection) { stub('Imap::Backup::Account::Connection', :imap => imap) }
-  let(:missing_mailbox_data) { stub('Data', :text => 'Unknown Mailbox: my_folder') }
-  let(:missing_mailbox_response) { stub('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) }
 
-  context 'with instance' do
-    subject { Imap::Backup::Account::Folder.new(connection, 'my_folder') }
+  subject { described_class.new(connection, 'my_folder') }
 
-    context '#uids' do
-      it 'lists available messages' do
-        imap.should_receive(:examine).with('my_folder')
-        imap.should_receive(:uid_search).with(['ALL']).and_return([5678, 123])
+  context '#uids' do
+    let(:uids) { [5678, 123] }
 
-        subject.uids.should == [123, 5678]
-      end
+    before { allow(imap).to receive(:uid_search).and_return(uids) }
+
+    it 'lists available messages' do
+      expect(subject.uids).to eq(uids.reverse)
+    end
 
-      it 'returns an empty array for missing mailboxes' do
-        imap.
-          should_receive(:examine).
-          with('my_folder').
-          and_raise(missing_mailbox_error)
+    context 'with missing mailboxes' do
+      before { allow(imap).to receive(:examine).and_raise(missing_mailbox_error) }
 
-        capturing_output do
-          expect(subject.uids).to eq([])
-        end
+      it 'returns an empty array' do
+        expect(subject.uids).to eq([])
       end
     end
+  end
 
-    context '#fetch' do
-      let(:message_body) { 'the body' }
-      let(:message) do
-        {
-          'RFC822' => message_body,
-          'other'  => 'xxx'
-        }
-      end
+  context '#fetch' do
+    let(:message_body) { double('the body', :force_encoding => nil) }
+    let(:message) { {'RFC822' => message_body, 'other' => 'xxx'} }
 
-      it 'requests the message, the flags and the date' do
-        imap.should_receive(:examine).with('my_folder')
-        imap.should_receive(:uid_fetch).
-              with([123], ['RFC822', 'FLAGS', 'INTERNALDATE']).
-              and_return([[nil, message]])
+    before { allow(imap).to receive(:uid_fetch).and_return([[nil, message]]) }
 
-        subject.fetch(123)
-      end
+    it 'returns the message' do
+      expect(subject.fetch(123)).to eq(message)
+    end
 
-      it "returns nil if the mailbox doesn't exist" do
-        imap.
-          should_receive(:examine).
-          with('my_folder').
-          and_raise(missing_mailbox_error)
+    context "if the mailbox doesn't exist" do
+      before { allow(imap).to receive(:examine).and_raise(missing_mailbox_error) }
 
-        capturing_output do
-          expect(subject.fetch(123)).to be_nil
-        end
+      it 'is nil' do
+        expect(subject.fetch(123)).to be_nil
       end
+    end
 
-      if RUBY_VERSION > '1.9'
-        it 'sets the encoding on the message' do
-          imap.stub!(:examine => nil, :uid_fetch => [[nil, message]])
-
-          message_body.should_receive(:force_encoding).with('utf-8')
+    if RUBY_VERSION > '1.9'
+      it 'sets the encoding on the message' do
+        subject.fetch(123)
 
-          subject.fetch(123)
-        end
+        expect(message_body).to have_received(:force_encoding).with('utf-8')
       end
     end
   end

data/spec/unit/configuration/asker_spec.rb

@@ -1,11 +1,48 @@
 # encoding: utf-8
 require 'spec_helper'
 
-module Imap::Backup::Configuration
-  describe Asker do
+module Imap::Backup
+  describe Configuration::Asker do
     let(:highline) { double }
+    let(:query) do
+      double(
+        'Query',
+        :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(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'],
+    ].each do |method, params, prompt|
+      context ".#{method}" do
+        it 'asks for input' do
+          described_class.send(method, *params)
 
-    subject { Asker.new(highline) }
+          expect(highline).to have_received(:ask).with("#{prompt}: ")
+        end
+
+        it 'returns the answer' do
+          expect(described_class.send(method, *params)).to eq(answer)
+        end
+      end
+    end
 
     context '#initialize' do
       its(:highline) { should eq(highline) }
@@ -13,9 +50,9 @@ module Imap::Backup::Configuration
 
     context '#email' do
       let(:email) { 'email@example.com' }
+      let(:answer) { email }
 
       before do
-        allow(highline).to receive(:ask).and_return(email)
         @result = subject.email
       end
 
@@ -70,9 +107,13 @@ module Imap::Backup::Configuration
 
     context '#backup_path' do
       let(:path) { '/path' }
+      let(:answer) { path }
 
       before do
-        allow(highline).to receive(:ask).and_return(path)
+        allow(highline).to receive(:ask) do |&b|
+          b.call query
+          path
+        end
         @result = subject.backup_path('', //)
       end
 

data/spec/unit/configuration/folder_chooser_spec.rb

@@ -2,145 +2,105 @@
 require 'spec_helper'
 
 describe Imap::Backup::Configuration::FolderChooser do
-
   include HighLineTestHelpers
-  include InputOutputTestHelpers
 
   context '#run' do
-    let(:connection) do
-      stub('Imap::Backup::Account::Connection')
-    end
-    let(:existing_account) do
-      {
-        :folders => [{:name => 'my_folder'}]
-      }
-    end
-    let(:empty_account) do
-      {
-        :folders => []
-      }
-    end
-    let(:remote_folders) do
-      folder1 = stub('folder', :name => 'my_folder')       # this one is already backed up
-      folder2 = stub('folder', :name => 'another_folder')
-      [folder1, folder2]
-    end
+    let(:connection) { double('Imap::Backup::Account::Connection', :folders => remote_folders) }
+    let(:account) { {:folders => []} }
+    let(:remote_folders) { [] }
+
+    subject { described_class.new(account) }
 
     before do
+      allow(Imap::Backup::Account::Connection).to receive(:new).with(account).and_return(connection)
       @input, @output = prepare_highline
+      allow(subject).to receive(:system)
+      allow(Imap::Backup.logger).to receive(:warn)
     end
 
-    context 'empty account' do
-      let(:account) { empty_account }
-
-      subject { Imap::Backup::Configuration::FolderChooser.new(account) }
+    context 'display' do
+      before { subject.run }
 
-      before do
-        connection.stub!(:folders).and_return([])
-        Imap::Backup::Account::Connection.stub!(:new).with(account).and_return(connection)
-        subject.stub(:system).with('clear')
+      it 'clears the screen' do
+        expect(subject).to have_received(:system).with('clear')
       end
 
-      it 'should connect to the account' do
-        Imap::Backup::Account::Connection.should_receive(:new).with(account).and_return(connection)
-
-        subject.run
+      it 'should show the menu' do
+        @output.string.should =~ %r{Add/remove folders}
       end
+    end
 
-      it 'should handle connection errors' do
-        Imap::Backup::Account::Connection.should_receive(:new).with(account).and_raise('error')
-        Imap::Backup::Configuration::Setup.highline.should_receive(:ask).with('Press a key ')
-
-        capturing_output do
-          subject.run
-        end.should =~ /connection failed/i
+    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, folder2]
       end
 
-      it 'should get a list of account folders' do
-        connection.should_receive(:folders).and_return([])
+      context 'display' do
+        before { subject.run }
 
-        subject.run
+        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')
+        end
       end
 
-      it 'clears the screen' do
-        subject.should_receive(:system).with('clear')
+      context 'adding folders' do
+        before do
+          allow(@input).to receive(:gets).and_return("2\n", "q\n")
 
-        subject.run
-      end
+          subject.run
+        end
 
-      it 'should show the menu' do
-        subject.run
-        
-        @output.string.should =~ %r{Add/remove folders}
+        specify 'are added to the account' do
+          expect(account[:folders]).to include({:name => 'another_folder'})
+        end
       end
 
-      it 'should return to the account menu' do
-        @input.should_receive(:gets).and_return("return\n")
+      context 'removing folders' do
+        before do
+          allow(@input).to receive(:gets).and_return("1\n", "q\n")
 
-        subject.run
-        
-        @output.string.should =~ %r{return to the account menu}
+          subject.run
+        end
+
+        specify 'are removed from the account' do
+          expect(account[:folders]).to_not include({:name => 'my_folder'})
+        end
       end
     end
 
-    context 'folder listing' do
-      let(:account) { existing_account }
-
-      subject { Imap::Backup::Configuration::FolderChooser.new(account) }
+    context 'when folders are not available' do
+      let(:remote_folders) { nil }
 
       before do
-        connection.stub!(:folders).and_return(remote_folders)
-        Imap::Backup::Account::Connection.stub!(:new).with(account).and_return(connection)
-        subject.stub(:system).with('clear')
-      end
-
-      it 'should list folders' do
+        allow(Imap::Backup::Configuration::Setup.highline).to receive(:ask).and_return("q")
         subject.run
- 
-        @output.string.should =~ /my_folder/
       end
 
-      it 'should show which folders are already being backed up' do
-        subject.run
- 
-        @output.string.should =~ /\d+\. \+ my_folder/
-        @output.string.should =~ /\d+\. \- another_folder/
+      it 'asks to press a key' do
+        expect(Imap::Backup::Configuration::Setup.highline).to have_received(:ask).with('Press a key ')
       end
+    end
 
-      it 'should add folders' do
-        state = :initial
-        @input.stub(:gets) do
-          case state
-          when :initial
-            state = :added
-            "2\n"         # choose 'another_folder'
-          else
-            "q\n"
-          end
-        end
-
+    context 'with connection errors' do
+      before 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
-
-        @output.string.should =~ /\d+\. \+ another_folder/
-        account[:folders].should include({:name => 'another_folder'})
       end
 
-      it 'should remove folders' do
-        state = :initial
-        @input.stub(:gets) do
-          case state
-          when :initial
-            state = :added
-            "1\n"
-          else
-            "q\n"
-          end
-        end
-
-        subject.run
+      it 'prints an error message' do
+        expect(Imap::Backup.logger).to have_received(:warn).with('Connection failed')
+      end
 
-        @output.string.should =~ /\d+\. \- my_folder/
-        account[:folders].should_not include({:name => 'my_folder'})
+      it 'asks to continue' do
+        expect(Imap::Backup::Configuration::Setup.highline).to have_received(:ask).with('Press a key ')
       end
     end
   end