imap-backup 0.0.3 → 0.0.4

data/spec/unit/configuration/connection_tester_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Imap::Backup::Configuration::ConnectionTester do
+
+  context '.test' do
+
+    it 'should try to connect' do
+      Imap::Backup::Account::Connection.should_receive(:new).with('foo')
+
+      Imap::Backup::Configuration::ConnectionTester.test('foo')
+    end
+
+    it 'should return success if the connection works' do
+      Imap::Backup::Account::Connection.stub!(:new).
+                                        with('foo')
+
+      result = Imap::Backup::Configuration::ConnectionTester.test('foo')
+
+      result.should =~ /successful/
+    end
+
+    it 'should handle no response' do
+      e = Net::IMAP::NoResponseError.new(stub('o', :data => stub('foo', :text => 'bar')))
+      Imap::Backup::Account::Connection.stub!(:new).
+                                        with('foo').
+                                        and_raise(e)
+
+      result = Imap::Backup::Configuration::ConnectionTester.test('foo')
+
+      result.should =~ /no response/i
+    end
+
+    it 'should handle other errors' do
+      Imap::Backup::Account::Connection.stub!(:new).
+                                        with('foo').
+                                        and_raise('error')
+
+      result = Imap::Backup::Configuration::ConnectionTester.test('foo')
+
+      result.should =~ /unexpected error/i
+    end
+
+  end
+
+end
+

data/spec/unit/configuration/folder_chooser_spec.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Imap::Backup::Configuration::FolderChooser do
+
+  include HighLineTestHelpers
+  include InputOutputTestHelpers
+
+  context '#run' do
+
+    before :each do
+      empty_account = {
+        :folders => []
+      }
+      @connection = setup_account(empty_account, [])
+      @input, @output = prepare_highline
+    end
+
+    def setup_account(account, remote_folders)
+      @account   = account
+      connection = stub('Imap::Backup::Account::Connection')
+      connection.stub!(:folders).and_return(remote_folders)
+      Imap::Backup::Account::Connection.stub!(:new).with(account).and_return(connection)
+      connection
+    end
+
+    subject { Imap::Backup::Configuration::FolderChooser.new(@account) }
+
+    it 'should connect to the account' do
+      Imap::Backup::Account::Connection.should_receive(:new).with(@account).and_return(@connection)
+
+      subject.run
+    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
+    end
+
+    it 'should get a list of account folders' do
+      @connection.should_receive(:folders).and_return([])
+
+      subject.run
+    end
+
+    it 'should show the menu' do
+      subject.run
+      
+      @output.string.should =~ %r{Add/remove folders}
+    end
+
+    it 'should return to the account menu' do
+      @input.should_receive(:gets).and_return("return\n")
+
+      subject.run
+      
+      @output.string.should =~ %r{return to the account menu}
+    end
+
+    context 'folder listing' do
+
+      before :each do
+        account = {
+          :folders => [{:name => 'my_folder'}]
+        }
+        folder1 = stub('folder', :name => 'my_folder')       # this one is already backed up
+        folder2 = stub('folder', :name => 'another_folder')
+        remote_folders = [folder1, folder2]
+        @connection = setup_account(account, remote_folders)
+      end
+
+      it 'should list folders' do
+        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/
+      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
+
+        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
+
+        @output.string.should =~ /\d+\. \- my_folder/
+        @account[:folders].should_not include( { :name => 'my_folder' } )
+      end
+
+
+    end
+
+  end
+
+end
+

data/spec/unit/configuration/list_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Imap::Backup::Configuration::List do
+  before :each do
+    @configuration_data = {
+      :accounts => [
+        {
+          :username => 'a1@example.com'
+        },
+        {
+          :username => 'a2@example.com',
+        },
+      ]
+    }
+    @store = stub('Imap::Backup::Configuration::Store', :data => @configuration_data)
+    Imap::Backup::Configuration::Store.stub!(:new => @store)
+  end
+
+  context '#initialize' do
+
+    context 'with account parameter' do
+      it 'should only create requested accounts' do
+        configuration = Imap::Backup::Configuration::List.new(['a2@example.com'])
+
+        configuration.accounts.should == @configuration_data[:accounts][1..1]
+      end
+    end
+
+  end
+
+  context 'instance methods' do
+
+    before :each do
+      @connection = stub('Imap::Backup::Account::Connection', :disconnect => nil)
+    end
+
+    subject { Imap::Backup::Configuration::List.new }
+
+    context '#each_connection' do
+
+      it 'should instantiate connections' do
+        Imap::Backup::Account::Connection.should_receive(:new).with(@configuration_data[:accounts][0]).and_return(@connection)
+        Imap::Backup::Account::Connection.should_receive(:new).with(@configuration_data[:accounts][1]).and_return(@connection)
+
+        subject.each_connection{}
+      end
+
+      it 'should call the block' do
+        Imap::Backup::Account::Connection.stub!(:new).and_return(@connection)
+        calls = 0
+
+        subject.each_connection do |a|
+          calls += 1
+          a.should == @connection
+        end
+        calls.should == 2
+      end
+
+      it 'should disconnect connections' do
+        Imap::Backup::Account::Connection.stub!(:new).and_return(@connection)
+
+        @connection.should_receive(:disconnect)
+
+        subject.each_connection {}
+      end
+
+    end
+
+  end
+
+end
+

data/spec/unit/configuration/setup_spec.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Imap::Backup::Configuration::Setup do
+
+  include HighLineTestHelpers
+
+  context '#initialize' do
+
+    it 'should not require the config file to exist' do
+      Imap::Backup::Configuration::Store.should_receive(:new).with(false)
+
+      Imap::Backup::Configuration::Setup.new
+    end
+
+  end
+
+  context '#run' do
+
+    before :each do
+      prepare_store
+      @input, @output = prepare_highline
+    end
+
+    def prepare_store
+      accounts = [
+        { :username => 'account@example.com' }
+      ]
+      @data  = {:accounts => accounts}
+      @store = stub('Imap::Backup::Configuration::Store', :data => @data, :path => '/base/path')
+      Imap::Backup::Configuration::Store.stub!(:new).with(false).and_return(@store)
+    end
+
+    subject { Imap::Backup::Configuration::Setup.new }
+
+    it 'should present a main menu' do
+      @input.should_receive(:eof?).and_return(false)
+      @input.should_receive(:gets).and_return("q\n")
+
+      subject.run
+
+      @output.string.should =~ /Choose an action:/
+      @output.string.should =~ /add account/
+      @output.string.should =~ /save and exit/
+      @output.string.should =~ /quit/
+    end
+
+    it 'should list accounts' do
+      subject.run
+
+      @output.string.should =~ /account@example.com/
+    end
+
+    it 'should edit accounts' do
+      state = :initial
+      @input.stub(:gets) do
+        case state
+        when :initial
+          state = :editing
+          "account@example.com\n"
+        else
+          "q\n"
+        end
+      end
+
+      @account = stub('Imap::Backup::Configuration::Account')
+      Imap::Backup::Configuration::Account.should_receive(:new).with(@store, 'account@example.com').and_return(@account)
+      @account.should_receive(:run).with()
+
+      subject.run
+    end
+
+    it 'should add accounts' do
+      state = :initial
+      @input.stub(:gets) do
+        case state
+        when :initial
+          state = :editing
+          "add\n"
+        else
+          "q\n"
+        end
+      end
+
+      Imap::Backup::Configuration::Asker.should_receive(:email).with().and_return('new@example.com')
+      Imap::Backup::Configuration::Account.should_receive(:new).with(@store, 'new@example.com')
+
+      subject.run
+
+      @data[:accounts].size.should == 2
+      @data[:accounts][1].should == {
+        :username   => "new@example.com",
+        :password   => "",
+        :local_path => "/base/path/new_example.com",
+        :folders    => []
+      }
+    end
+
+    it 'should save the configuration' do
+      @input.should_receive(:gets).with().and_return("save\n")
+      @store.should_receive(:save).with()
+
+      subject.run
+    end
+
+    it 'should exit' do
+      @input.should_receive(:gets).with().and_return("quit\n")
+
+      subject.run
+    end
+
+  end
+
+end
+

data/spec/unit/configuration/store_spec.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+load File.expand_path( '../../spec_helper.rb', File.dirname(__FILE__) )
+
+describe Imap::Backup::Configuration::Store do
+
+  before :all do
+    @configuration_directory = Imap::Backup::Configuration::Store::CONFIGURATION_DIRECTORY
+    Imap::Backup::Configuration::Store.instance_eval { remove_const :'CONFIGURATION_DIRECTORY' }
+    Imap::Backup::Configuration::Store::CONFIGURATION_DIRECTORY = '/base/path'
+  end
+
+  after :all do
+    Imap::Backup::Configuration::Store.instance_eval { remove_const :'CONFIGURATION_DIRECTORY' }
+    Imap::Backup::Configuration::Store::CONFIGURATION_DIRECTORY = @configuration_directory
+  end
+
+  context '#initialize' do
+
+    before :each do
+      Imap::Backup::Utils.stub!(:check_permissions => nil)
+    end
+
+    it 'by default, should fail if the config file is missing' do
+      File.should_receive(:directory?).with('/base/path').and_return(true)
+      File.should_receive(:exist?).with('/base/path/config.json').and_return(false)
+
+      expect do
+        Imap::Backup::Configuration::Store.new
+      end.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)
+    end
+
+    it 'should not fail if fail_if_missing is false' do
+      File.should_receive(:directory?).with('/base/path').and_return(true)
+      File.should_receive(:exist?).with('/base/path/config.json').and_return(false)
+
+      expect do
+        Imap::Backup::Configuration::Store.new(false)
+      end.to_not raise_error
+    end
+
+    it 'should fail if the config file permissions are too lax' do
+      File.stub!(:exist?).with('/base/path/config.json').and_return(true)
+
+      Imap::Backup::Utils.should_receive(:check_permissions).with('/base/path/config.json', 0600).and_raise('Error')
+
+      expect do
+        Imap::Backup::Configuration::Store.new
+      end.to raise_error(RuntimeError, 'Error')
+    end
+
+    it 'should load the config file' do
+      File.stub!(:exist?).with('/base/path/config.json').and_return(true)
+
+      configuration = 'JSON string'
+      File.should_receive(:read).with('/base/path/config.json').and_return(configuration)
+      JSON.should_receive(:parse).with(configuration, :symbolize_names => true)
+
+      Imap::Backup::Configuration::Store.new
+    end
+
+  end
+
+  context '#save' do
+
+    before :each do
+      # initialize
+      File.stub!(:directory?).with('/base/path').and_return(false)
+      File.stub!(:exist?).with('/base/path/config.json').and_return(false)
+      # save
+      @file = stub('File')
+      File.stub!(:directory?).with('/base/path').and_return(false)
+      FileUtils.stub!(:mkdir).with('/base/path')
+      Imap::Backup::Utils.stub!(:stat).with('/base/path').and_return(0700)
+      FileUtils.stub!(:chmod).with(0700, '/base/path')
+      File.stub!(:open).with('/base/path/config.json', 'w') { |&b| b.call @file }
+      JSON.stub!(:pretty_generate => 'JSON output')
+      @file.stub!(:write).with('JSON output')
+      FileUtils.stub!(:chmod).with(0600, '/base/path/config.json')
+    end
+
+    subject { Imap::Backup::Configuration::Store.new(false) }
+
+    it 'should create the config directory' do
+      File.should_receive(:directory?).with('/base/path').and_return(false)
+      FileUtils.should_receive(:mkdir).with('/base/path')
+
+      subject.save
+    end
+
+    it 'should save the config file' do
+      @file.should_receive(:write).with('JSON output')
+
+      subject.save
+    end
+
+    it 'should set config perms to 0600' do
+      FileUtils.should_receive(:chmod).with(0600, '/base/path/config.json')
+
+      subject.save
+    end
+
+    context 'saving accounts' do
+
+      before :each do
+        # initialize
+        File.stub!(:exist?).with('/base/path/config.json').and_return(true)
+        Imap::Backup::Utils.stub!(:check_permissions).with('/base/path/config.json', 0600)
+        folders = [
+          { :name => 'A folder' },
+        ]
+        File.stub!(:read).with('/base/path/config.json').and_return('xxx')
+        JSON.stub!(:parse).with('xxx', :symbolize_names => true).and_return(configuration(folders))
+        # save
+        File.stub!(:directory?).with('/my/backup/path').and_return(false)
+        FileUtils.stub!(:mkdir).with('/my/backup/path')
+        Imap::Backup::Utils.stub!(:stat).with('/my/backup/path').and_return(0700)
+        File.stub!(:directory?).with('/my/backup/path/A folder').and_return(false)
+        FileUtils.stub!(:mkdir).with('/my/backup/path/A folder')
+        Imap::Backup::Utils.stub!(:stat).with('/my/backup/path/A folder').and_return(0700)
+      end
+
+      def configuration(folders)
+        {
+          :accounts => [
+            :local_path => '/my/backup/path',
+            :folders    => folders
+          ]
+        }
+      end
+
+      subject { Imap::Backup::Configuration::Store.new }
+
+      it 'should create account directories' do
+        File.should_receive(:directory?).with('/my/backup/path').and_return(false)
+        FileUtils.should_receive(:mkdir).with('/my/backup/path')
+
+        subject.save
+      end
+
+      it 'should create folder directories' do
+        File.should_receive(:directory?).with('/my/backup/path/A folder').and_return(false)
+        FileUtils.should_receive(:mkdir).with('/my/backup/path/A folder')
+
+        subject.save
+      end
+
+      it 'should set directory permissions, if necessary' do
+        Imap::Backup::Utils.stub!(:stat).with('/my/backup/path/A folder').and_return(0755)
+        FileUtils.should_receive(:chmod).with(0700, '/my/backup/path/A folder')
+
+        subject.save
+      end
+
+      it 'should create a path for folders with slashes' do
+        folders = [
+          { :name => 'folder/path' },
+        ]
+        JSON.stub!(:parse).with('xxx', :symbolize_names => true).and_return(configuration(folders))
+
+        File.should_receive(:directory?).with('/my/backup/path/folder').and_return(true)
+        Imap::Backup::Utils.should_receive(:stat).with('/my/backup/path/folder').and_return(0700)
+        File.should_receive(:directory?).with('/my/backup/path/folder/path').and_return(true)
+        Imap::Backup::Utils.should_receive(:stat).with('/my/backup/path/folder/path').and_return(0700)
+
+        subject.save
+      end
+
+    end
+
+  end
+
+end
+