imap-backup 1.0.9 → 1.0.10

data/spec/unit/configuration/list_spec.rb

@@ -2,74 +2,66 @@
 require 'spec_helper'
 
 describe Imap::Backup::Configuration::List do
-  let(:configuration_data) do
-    {
-      :accounts => [
-        {
-          :username => 'a1@example.com'
-        },
-        {
-          :username => 'a2@example.com',
-        },
-      ]
-    }
+  let(:accounts) do
+    [
+      {:username => 'a1@example.com'},
+      {:username => 'a2@example.com'},
+    ]
   end
-  let(:store) { stub('Imap::Backup::Configuration::Store', :data => configuration_data) }
+  let(:store) do
+    double('Imap::Backup::Configuration::Store', :data => {:accounts => accounts})
+  end
+  let(:exists) { true }
 
   before do
-    Imap::Backup::Configuration::Store.stub!(:new => store)
-    Imap::Backup::Configuration::Store.stub!(:exist? => true)
+    allow(Imap::Backup::Configuration::Store).to receive(:new).and_return(store)
+    allow(Imap::Backup::Configuration::Store).to receive(:exist?).and_return(exists)
   end
 
+  subject { described_class.new }
+
   context '#initialize' do
-    it 'fails if the configuration file is missing' do
-      Imap::Backup::Configuration::Store.should_receive(:exist?).and_return(false)
+    context 'with account parameter' do
+      subject { described_class.new(['a2@example.com']) }
 
-      expect {
-        Imap::Backup::Configuration::List.new
-      }.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)
+      it 'should only create requested accounts' do
+        expect(subject.accounts).to eq([accounts[1]])
+      end
     end
 
-    context 'with account parameter' do
-      it 'should only create requested accounts' do
-        configuration = Imap::Backup::Configuration::List.new(['a2@example.com'])
+    context 'without an account parameter' do
+      it 'selects all accounts' do
+        expect(subject.accounts).to eq(accounts)
+      end
+    end
 
-        configuration.accounts.should == configuration_data[:accounts][1..1]
+    context 'when the configuration file is missing' do
+      let(:exists) { false }
+
+      it 'fails' do
+        expect {
+          described_class.new
+        }.to raise_error(Imap::Backup::ConfigurationNotFound, /not found/)
       end
     end
   end
 
   context 'instance methods' do
-    let(:connection) { stub('Imap::Backup::Account::Connection', :disconnect => nil) }
+    let(:connection1) { double('Imap::Backup::Account::Connection', :disconnect => nil) }
+    let(:connection2) { double('Imap::Backup::Account::Connection', :disconnect => nil) }
 
-    subject { Imap::Backup::Configuration::List.new }
+    before do
+      allow(Imap::Backup::Account::Connection).to receive(:new).with(accounts[0]).and_return(connection1)
+      allow(Imap::Backup::Account::Connection).to receive(:new).with(accounts[1]).and_return(connection2)
+    end
 
     context '#each_connection' do
+      specify "calls the block with each account's connection" do
+        connections = []
 
-      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 { |a| connections << a }
 
-        subject.each_connection {}
+        expect(connections).to eq([connection1, connection2])
       end
     end
   end

data/spec/unit/configuration/setup_spec.rb

@@ -7,37 +7,41 @@ describe Imap::Backup::Configuration::Setup do
   context '#initialize' do
     context 'without a config file' do
       it 'works' do
-        Imap::Backup::Configuration::Setup.new
+        described_class.new
       end
     end
   end
 
   context '#run' do
-    before :each do
-      prepare_store
-      @input, @output = prepare_highline
-      subject.stub(:system => nil)
+    let(:account1) { {:username => 'account@example.com'} }
+    let(:account) { double('Imap::Backup::Configuration::Account', :run => nil) }
+    let(:data) { {:accounts => [account1]} }
+    let(:store) do
+      double(
+        'Imap::Backup::Configuration::Store',
+        :data => data,
+        :path => '/base/path'
+      )
     end
 
-    def prepare_store
-      @account1 = {:username => 'account@example.com'}
-      @data     = {:accounts => [@account1]}
-      @store    = stub('Imap::Backup::Configuration::Store', :data => @data, :path => '/base/path')
-      Imap::Backup::Configuration::Store.stub!(:new).and_return(@store)
+    before :each do
+      allow(Imap::Backup::Configuration::Store).to receive(:new).and_return(store)
+      @input, @output = prepare_highline
+      allow(@input).to receive(:eof?).and_return(false)
+      allow(@input).to receive(:gets).and_return("q\n")
+      allow(subject).to receive(:system)
     end
 
-    subject { Imap::Backup::Configuration::Setup.new }
+    subject { described_class.new }
 
-    it 'should present a main menu' do
-      @input.should_receive(:eof?).and_return(false)
-      @input.should_receive(:gets).and_return("q\n")
+    context 'main menu' do
+      before { subject.run }
 
-      subject.run
-
-      @output.string.should =~ /Choose an action:/
-      @output.string.should =~ /add account/
-      @output.string.should =~ /save and exit/
-      @output.string.should =~ /quit/
+      %w(add\ account save\ and\ exit quit).each do |choice|
+        it "includes #{choice}" do
+          expect(@output.string).to include(choice)
+        end
+      end
     end
 
     it 'clears the screen' do
@@ -52,57 +56,32 @@ describe Imap::Backup::Configuration::Setup do
       @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
+    context 'adding accounts' do
+      let(:blank_account) do
+        {
+          :username => "new@example.com",
+          :password => "",
+          :local_path => "/base/path/new_example.com",
+          :folders => []
+        }
       end
 
-      @account = stub('Imap::Backup::Configuration::Account')
-      allow(Imap::Backup::Configuration::Account).to receive(:new).with(@store, @account1, anything).and_return(@account)
-      @account.should_receive(:run).with()
+      before do
+        allow(@input).to receive(:gets).and_return("add\n", "q\n")
+        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 'should add accounts' do
-      state = :initial
-      @input.stub(:gets) do
-        case state
-        when :initial
-          state = :editing
-          "add\n"
-        else
-          "q\n"
-        end
+        subject.run
       end
 
-      blank_account = {:username=>"new@example.com", :password=>"", :local_path=>"/base/path/new_example.com", :folders=>[]}
-      Imap::Backup::Configuration::Asker.should_receive(:email).with().and_return('new@example.com')
-      @account = stub('Imap::Backup::Configuration::Account')
-      allow(Imap::Backup::Configuration::Account).to receive(:new).with(@store, blank_account, anything).and_return(@account)
-      @account.should_receive(:run).once
-
-      subject.run
-
-      @data[:accounts].size.should == 2
-      @data[:accounts][1].should == {
-        :username   => "new@example.com",
-        :password   => "",
-        :local_path => "/base/path/new_example.com",
-        :folders    => []
-      }
+      it 'adds account data' do
+        expect(data[:accounts][1]).to eq(blank_account)
+      end
     end
 
     it 'should save the configuration' do
       @input.should_receive(:gets).with().and_return("save\n")
-      @store.should_receive(:save).with()
+      store.should_receive(:save).with()
 
       subject.run
     end

data/spec/unit/configuration/store_spec.rb

@@ -1,119 +1,111 @@
 # encoding: utf-8
 require 'spec_helper'
+require 'json'
 
 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
+  let(:file_path) { '/base/path/config.json' }
+  let(:file_exists) { true }
+  let(:directory) { '/base/path' }
+  let(:directory_exists) { true }
+  let(:data) { {:the => :config} }
+  let(:configuration) { data.to_json }
+
+  before do
+    stub_const('Imap::Backup::Configuration::Store::CONFIGURATION_DIRECTORY', directory)
+    allow(File).to receive(:directory?).with(directory).and_return(directory_exists)
+    allow(File).to receive(:exist?).with(file_path).and_return(file_exists)
+    allow(File).to receive(:read).with(file_path).and_return(configuration)
+    allow(JSON).to receive(:parse).with(configuration, anything).and_return(data)
   end
 
   context '.exist?' do
-    it 'checks if the file exists' do
-      File.should_receive(:exist?).with('/base/path/config.json').and_return(true)
-
-      Imap::Backup::Configuration::Store.exist?
+    [true, false].each do |exists|
+      state = exists ? 'exists' : "doesn't exist"
+      context "when the file #{state}" do
+        let(:file_exists) { exists }
+
+        it "returns #{exists}" do
+          expect(described_class.exist?).to eq(file_exists)
+        end
+      end
     end
   end
 
   context '#initialize' do
     before :each do
-      Imap::Backup::Utils.stub!(:check_permissions => nil)
+      allow(Imap::Backup::Utils).to receive(:check_permissions).and_return(nil)
     end
 
-    it 'should not fail if the configuration 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)
+    context 'loading' do
+      subject { described_class.new }
 
-      expect do
-        Imap::Backup::Configuration::Store.new
-      end.to_not raise_error
+      it 'sets data' do
+        expect(subject.data).to eq(data)
+      end
     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')
+    context 'if the configuration file is missing' do
+      let(:file_exists) { false }
 
-      expect do
-        Imap::Backup::Configuration::Store.new
-      end.to raise_error(RuntimeError, 'Error')
+      it "doesn't fail" do
+        expect do
+          described_class.new
+        end.to_not raise_error
+      end
     end
 
-    it 'should load the config file' do
-      File.stub!(:exist?).with('/base/path/config.json').and_return(true)
+    context 'if the config file permissions are too lax' do
+      let(:file_exists) { 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)
+      before do
+        allow(Imap::Backup::Utils).to receive(:check_permissions).with(file_path, 0600).and_raise('Error')
+      end
 
-      Imap::Backup::Configuration::Store.new
+      it 'fails' do
+        expect do
+          described_class.new
+        end.to raise_error(RuntimeError, 'Error')
+      end
     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')
+    let(:directory_exists) { false }
+    let(:file_exists) { false }
+    let(:file) { double('File', :write => nil) }
+
+    before do
+      allow(FileUtils).to receive(:mkdir)
+      allow(FileUtils).to receive(:chmod)
+      allow(Imap::Backup::Utils).to receive(:stat).with(directory).and_return(0700)
+      allow(Imap::Backup::Utils).to receive(:stat).with(file_path).and_return(0600)
+      allow(File).to receive(:open).with(file_path, 'w') { |&b| b.call file }
+      allow(JSON).to receive(:pretty_generate).and_return('JSON output')
     end
 
-    subject { Imap::Backup::Configuration::Store.new }
-
-    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 { described_class.new }
 
+    it 'creates the config directory' do
       subject.save
-    end
 
-    it 'should save the config file' do
-      @file.should_receive(:write).with('JSON output')
+      expect(FileUtils).to have_received(:mkdir).with(directory)
+    end
 
+    it 'saves the configuration' do
       subject.save
-    end
 
-    it 'should set config perms to 0600' do
-      FileUtils.should_receive(:chmod).with(0600, '/base/path/config.json')
+      expect(file).to have_received(:write).with('JSON output')
+    end
 
+    it 'sets config perms to 0600' do
       subject.save
+
+      expect(FileUtils).to have_received(:chmod).with(0600, file_path)
     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)
+      let(:folders) { [{ :name => 'A folder' }] }
+      let(:data) do
         {
           :accounts => [
             :local_path => '/my/backup/path',
@@ -121,40 +113,56 @@ describe Imap::Backup::Configuration::Store do
           ]
         }
       end
+      let(:file_exists) { true }
+      let(:a_folder_perms) { 0700 }
+
+      before do
+        allow(Imap::Backup::Utils).to receive(:check_permissions)
+        allow(File).to receive(:directory?).with('/my/backup/path').and_return(false)
+        allow(Imap::Backup::Utils).to receive(:stat).with('/my/backup/path').and_return(0700)
+        allow(File).to receive(:directory?).with('/my/backup/path/A folder').and_return(false)
+        allow(Imap::Backup::Utils).to receive(:stat).with('/my/backup/path/A folder').and_return(a_folder_perms)
+      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')
-
+      it 'creates account directories' do
         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')
+        expect(FileUtils).to have_received(:mkdir).with('/my/backup/path')
+      end
 
+      it 'creates folder directories' do
         subject.save
+
+        expect(FileUtils).to have_received(:mkdir).with('/my/backup/path/A folder')
       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')
+      context 'when directory permissions are too open' do
+        let(:a_folder_perms) { 0755 }
 
-        subject.save
+        it 'sets premissions' do
+          subject.save
+
+          expect(FileUtils).to have_received(:chmod).with(0700, '/my/backup/path/A folder')
+        end
       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))
+      context 'when folders have slashes' do
+        let(:directory_exists) { true }
+        let(:folders) { [{:name => 'folder/path'}] }
 
-        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)
+        before do
+          allow(File).to receive(:directory?).with('/my/backup/path/folder').and_return(true)
+          allow(Imap::Backup::Utils).to receive(:stat).with('/my/backup/path/folder').and_return(0700)
+          allow(File).to receive(:directory?).with('/my/backup/path/folder/path').and_return(false)
+          allow(Imap::Backup::Utils).to receive(:stat).with('/my/backup/path/folder/path').and_return(0700)
+          allow(FileUtils).to receive(:mkdir)
+        end
 
-        subject.save
+        it 'creates subdirectories' do
+          subject.save
+
+          expect(FileUtils).to have_received(:mkdir).with('/my/backup/path/folder/path')
+        end
       end
     end
   end