imap-backup 0.0.3 → 0.0.4

data/lib/imap/backup/downloader.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+require 'rubygems' if RUBY_VERSION < '1.9'
 require 'json'
 
 module Imap

data/lib/imap/backup/serializer/directory.rb

@@ -6,13 +6,11 @@ module Imap
     module Serializer
       class Directory
 
-        include Imap::Backup::Utils
-
         def initialize(path, folder)
           @path, @folder = path, folder
           permissions = 0700
-          check_permissions(@path, permissions)
-          make_folder(@path, @folder, permissions)
+          Imap::Backup::Utils.check_permissions(@path, permissions)
+          Imap::Backup::Utils.make_folder(@path, @folder, permissions)
         end
 
         def uids

data/lib/imap/backup/utils.rb

@@ -5,16 +5,22 @@ module Imap
   module Backup
     module Utils
 
-      def check_permissions(filename, limit)
-        stat   = File.stat(filename)
-        actual = stat.mode & 0777
+      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 make_folder(base_path, path, permissions)
+      def self.stat(filename)
+        return nil unless File.exist?(filename)
+
+        stat   = File.stat(filename)
+        stat.mode & 0777
+      end
+
+      def self.make_folder(base_path, path, permissions)
         parts = path.split('/')
         return if parts.size == 0
         full_path = File.join(base_path, path)
@@ -25,7 +31,7 @@ module Imap
 
       private
 
-      def oct(permissions)
+      def self.oct(permissions)
         "0%o" % permissions
       end
 

data/lib/imap/backup/version.rb

@@ -2,7 +2,7 @@ module Imap
   module Backup
     MAJOR    = 0
     MINOR    = 0
-    REVISION = 3
+    REVISION = 4
     VERSION  = [ MAJOR, MINOR, REVISION ].map( &:to_s ).join( '.' )
   end
 end

data/spec/spec_helper.rb

@@ -14,3 +14,29 @@ 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
+
+module InputOutputTestHelpers
+
+  def capturing_output
+    output = StringIO.new
+    $stdout = output
+    yield
+    output.string
+  ensure
+    $stdout = STDOUT
+  end
+
+end
+

data/spec/unit/configuration/account_spec.rb

@@ -0,0 +1,224 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Imap::Backup::Configuration::Account do
+
+  include HighLineTestHelpers
+  include InputOutputTestHelpers
+
+  def choose_menu_item(item)
+    @state = :initial
+    @input.should_receive(:gets) do
+      case @state
+      when :initial
+        @state = :done
+        "#{item}\n"
+      when :done
+        "quit\n"
+      end
+    end
+  end
+
+  context '#run' do
+
+    before :each do
+      @account1_path = '/backup/path'
+      @account1 = {
+        :username   => 'user@example.com',
+        :password   => 'secret',
+        :local_path => @account1_path,
+        :folders    => [ { :name => 'my_folder' }, { :name => 'another_folder' } ]
+      }
+      @other_account_path = '/existing/path'
+      @other_account = {
+        :username   => 'existing@example.com',
+        :password   => 'secret',
+        :local_path => @other_account_path,
+        :folders    => []
+      }
+      @data = {:accounts => [@account1, @other_account]}
+      @store = stub('Imap::Backup::Configuration::Store')
+      @store.stub!(:data => @data)
+      @input, @output = prepare_highline
+    end
+
+    subject { Imap::Backup::Configuration::Account.new(@store, @account1) }
+
+    context 'menu' do
+
+      it 'should show a menu' do
+        subject.run
+
+        @output.string.should =~ /modify email/
+        @output.string.should =~ /modify password/
+        @output.string.should =~ /modify backup path/
+        @output.string.should =~ /choose backup folders/
+        @output.string.should =~ /test authentication/
+        @output.string.should =~ /delete/
+        @output.string.should =~ /return to main/
+      end
+
+      it 'should show account details in the menu' do
+        subject.run
+
+        @output.string.should =~ /email:\s+user@example.com/
+        @output.string.should =~ /password:\s+x+/
+        @output.string.should =~ %r{path:\s+/backup/path}
+        @output.string.should =~ /folders:\s+my_folder, another_folder/
+      end
+
+      it 'should indicate that a password is not set' do
+        @account1[:password] = ''
+
+        subject.run
+
+        @output.string.should =~ /password:\s+\(unset\)/
+      end
+
+    end
+
+    context 'email' do
+
+      it 'should modify the email address' do
+        Imap::Backup::Configuration::Asker.should_receive(:email).once.and_return('new@example.com')
+
+        choose_menu_item 'modify email'
+
+        subject.run
+
+        @output.string.should =~ /email:\s+new@example.com/
+        @account1[:username].should == 'new@example.com'
+      end
+
+      it 'should do nothing if it creates a duplicate' do
+        Imap::Backup::Configuration::Asker.should_receive(:email).once.and_return('existing@example.com')
+
+        choose_menu_item 'modify email'
+
+        capturing_output do
+          subject.run
+        end.should =~ /there is already an account set up with that email address/i
+      end
+
+    end
+
+    context 'password' do
+
+      it 'should update the password' do
+        Imap::Backup::Configuration::Asker.should_receive(:password).once.and_return('new_pwd')
+
+        choose_menu_item 'modify password'
+
+        subject.run
+
+        @account1[:password].should == 'new_pwd'
+      end
+
+      it 'should do nothing if the user cancels' do
+        Imap::Backup::Configuration::Asker.should_receive(:password).once.and_return(nil)
+
+        choose_menu_item 'modify password'
+
+        subject.run
+
+        @account1[:password].should == 'secret'
+      end
+
+    end
+
+    context 'backup_path' do
+
+      it 'should update the path' do
+        Imap::Backup::Configuration::Asker.should_receive(:backup_path).once do |default, validator|
+          validator.call('new/path')
+          '/new/path'
+        end
+
+        choose_menu_item 'modify backup path'
+
+        subject.run
+
+        @account1[:local_path].should == '/new/path'
+      end
+
+      it 'should validate that the path is not used by other backups' do
+        Imap::Backup::Configuration::Asker.should_receive(:backup_path) do |default, validator|
+          validator.call(@other_account_path)
+          '/path'
+        end
+
+        choose_menu_item 'modify backup path'
+
+        capturing_output do
+          subject.run
+        end.should =~ %r{The path '/existing/path' is used to backup the account 'existing@example.com'}
+      end
+
+    end
+
+    it 'should add/remove folders' do
+      @chooser = stub('Imap::Backup::Configuration::FolderChooser')
+      Imap::Backup::Configuration::FolderChooser.should_receive(:new).with(@account1).and_return(@chooser)
+      @chooser.should_receive(:run).with().once
+
+      choose_menu_item 'choose backup folders'
+
+      subject.run
+    end
+
+    it 'should allow testing the connection' do
+      Imap::Backup::Configuration::ConnectionTester.should_receive(:test).with(@account1).and_return('All fine')
+
+      choose_menu_item 'test authentication'
+
+      capturing_output do
+        subject.run
+      end.should == "All fine\n"
+    end
+
+    context 'deletion' do
+
+      it 'should confirm deletion' do
+        Imap::Backup::Configuration::Setup.highline.should_receive(:agree).with("Are you sure? (y/n) ").and_return(true)
+
+        choose_menu_item 'delete'
+
+        subject.run
+      end
+
+      it 'should delete the account' do
+        Imap::Backup::Configuration::Setup.highline.stub!(:agree).with("Are you sure? (y/n) ").and_return(true)
+
+        choose_menu_item 'delete'
+
+        subject.run
+
+        @data[:accounts].should_not include(@account1)
+      end
+
+      it 'should not delete if confirmation is not given' do
+        Imap::Backup::Configuration::Setup.highline.stub!(:agree).with("Are you sure? (y/n) ").and_return(false)
+
+        choose_menu_item 'delete'
+
+        subject.run
+
+        @data[:accounts].should include(@account1)
+      end
+
+    end
+
+    context 'return to main menu' do
+
+      it 'should return' do
+        @input.stub!(:gets).with().and_return("return\n")
+
+        subject.run.should be_nil
+      end
+
+    end
+
+  end
+
+end
+

data/spec/unit/configuration/asker_spec.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Imap::Backup::Configuration::Asker do
+
+  context '.email' do
+
+    it 'should ask for an email' do
+      Imap::Backup::Configuration::Setup.highline.should_receive(:ask).with(/email/)
+
+      Imap::Backup::Configuration::Asker.email
+    end
+
+    it 'should validate the address' do
+      Imap::Backup::Configuration::Setup.highline.should_receive(:ask).with(/email/) do |&block|
+        q = stub('HighLine::Question', :default=  => nil,
+                                       :readline= => nil,
+                                       :responses => {})
+        q.should_receive(:validate=).with(instance_of(Regexp))
+
+        block.call q
+      end
+
+      Imap::Backup::Configuration::Asker.email
+    end
+
+    it 'should return the address' do
+      Imap::Backup::Configuration::Setup.highline.stub!(:ask).with(/email/).and_return('new@example.com')
+
+      Imap::Backup::Configuration::Asker.email.should == 'new@example.com'
+    end
+
+  end
+
+  context '.password' do
+
+    before :each do
+      Imap::Backup::Configuration::Setup.highline.stub!(:ask).with(/^password/).and_return('secret')
+      Imap::Backup::Configuration::Setup.highline.stub!(:ask).with(/^repeat password/).and_return('secret')
+    end
+
+    it 'should ask for a password and confirmation' do
+      Imap::Backup::Configuration::Setup.highline.should_receive(:ask).with(/^password/).and_return('secret')
+      Imap::Backup::Configuration::Setup.highline.should_receive(:ask).with(/^repeat password/).and_return('secret')
+
+      Imap::Backup::Configuration::Asker.password
+    end
+
+    it 'should return the password' do
+      Imap::Backup::Configuration::Asker.password.should == 'secret'
+    end
+
+    it "should ask again if the passwords don't match" do
+      state = :password1
+      Imap::Backup::Configuration::Setup.highline.stub!(:ask) do
+        case state
+        when :password1
+          state = :confirmation1
+          'secret'
+        when :confirmation1
+          state = :retry?
+          'wrong!!!'
+        when :retry?
+          state = :password2
+          'y'
+        when :password2
+          state = :confirmation2
+          'secret'
+        when :confirmation2
+          'secret'
+        end
+      end
+
+      Imap::Backup::Configuration::Asker.password
+    end
+
+    it 'should return nil if the user cancels' do
+      state = :password1
+      Imap::Backup::Configuration::Setup.highline.stub!(:ask) do
+        case state
+        when :password1
+          state = :confirmation1
+          'secret'
+        when :confirmation1
+          state = :retry?
+          'wrong!!!'
+        when :retry?
+          state = :password2
+          'n'
+        end
+      end
+
+      Imap::Backup::Configuration::Asker.password.should be_nil
+    end
+
+  end
+
+  context '.backup_path' do
+
+    it 'should ask for a directory' do
+      validator = /validator/
+      Imap::Backup::Configuration::Setup.highline.should_receive(:ask).with(/directory/) do |&block|
+        q = stub('HighLine::Question', :responses => {}, :readline= => nil)
+        q.should_receive(:default=).with('default path')
+        q.should_receive(:validate=).with(validator)
+
+        block.call q
+      end
+
+      Imap::Backup::Configuration::Asker.backup_path('default path', validator)
+    end
+
+    it 'should return the choice' do
+      Imap::Backup::Configuration::Setup.highline.should_receive(:ask).with(/directory/).and_return('/path')
+
+      Imap::Backup::Configuration::Asker.backup_path('default path', //).should == '/path'
+    end
+
+  end
+
+end
+