backup_checksum 3.0.23

data/spec/syncer/cloud_files_spec.rb

@@ -0,0 +1,192 @@
+# encoding: utf-8
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+class Parallel; end
+
+describe Backup::Syncer::CloudFiles do
+  describe '#perform!' do
+    let(:syncer)     { Backup::Syncer::CloudFiles.new }
+    let(:connection) { stub('connection',
+      :directories => stub('directories', :get => container)) }
+    let(:container)     { stub('container', :files => files) }
+    let(:files)      { [] }
+    let(:content)    { stub('content') }
+
+    before :each do
+      Fog::Storage.stubs(:new).returns connection
+      File.stubs(:open).yields content
+      File.stubs(:exist?).returns true
+      files.stubs(:create).returns true
+
+      syncer.directories << 'tmp'
+      syncer.path = 'storage'
+      Backup::Syncer::S3::SyncContext.any_instance.
+        stubs(:`).returns 'MD5(tmp/foo)= 123abcdef'
+    end
+
+    it "respects the concurrency_type setting with threads" do
+      syncer.concurrency_type = :threads
+
+      Parallel.expects(:each).with(anything, {:in_threads => 2}, anything)
+
+      syncer.perform!
+    end
+
+    it "respects the parallel thread count" do
+      syncer.concurrency_type  = :threads
+      syncer.concurrency_level = 10
+
+      Parallel.expects(:each).with(anything, {:in_threads => 10}, anything)
+
+      syncer.perform!
+    end
+
+    it "respects the concurrency_type setting with processors" do
+      syncer.concurrency_type = :processes
+
+      Parallel.expects(:each).with(anything, {:in_processes => 2}, anything)
+
+      syncer.perform!
+    end
+
+    it "respects the parallel thread count" do
+      syncer.concurrency_type  = :processes
+      syncer.concurrency_level = 10
+
+      Parallel.expects(:each).with(anything, {:in_processes => 10}, anything)
+
+      syncer.perform!
+    end
+
+    context 'file exists locally' do
+      it "uploads a file if it does not exist remotely" do
+        files.expects(:create).with(:key => 'storage/tmp/foo', :body => content)
+
+        syncer.perform!
+      end
+
+      it "uploads a file if it exists remotely with a different MD5" do
+        files << stub('file', :key => 'storage/tmp/foo', :etag => 'abcdef123')
+
+        files.expects(:create).with(:key => 'storage/tmp/foo', :body => content)
+
+        syncer.perform!
+      end
+
+      it "does nothing if the file exists remotely with the same MD5" do
+        files << stub('file', :key => 'storage/tmp/foo', :etag => '123abcdef')
+
+        files.expects(:create).never
+
+        syncer.perform!
+      end
+
+      it "skips the file if it no longer exists locally" do
+        File.stubs(:exist?).returns false
+
+        files.expects(:create).never
+
+        syncer.perform!
+      end
+
+      it "respects the given path" do
+        syncer.path = 'box'
+
+        files.expects(:create).with(:key => 'box/tmp/foo', :body => content)
+
+        syncer.perform!
+      end
+
+      it "uploads the content of the local file" do
+        files.expects(:create).with(:key => 'storage/tmp/foo', :body => content)
+
+        syncer.perform!
+      end
+
+      it "creates the connection with the provided credentials" do
+        syncer.api_key    = 'my-key'
+        syncer.username   = 'my-name'
+        syncer.auth_url   = 'my-auth'
+        syncer.servicenet = 'my-servicenet'
+
+        Fog::Storage.expects(:new).with(
+          :provider             => 'Rackspace',
+          :rackspace_api_key    => 'my-key',
+          :rackspace_username   => 'my-name',
+          :rackspace_auth_url   => 'my-auth',
+          :rackspace_servicenet => 'my-servicenet'
+        ).returns connection
+
+        syncer.perform!
+      end
+
+      it "uses the container with the given name" do
+        syncer.container = 'leaky'
+
+        connection.directories.expects(:get).with('leaky').returns(container)
+
+        syncer.perform!
+      end
+
+      it "creates the container if one does not exist" do
+        syncer.container = 'leaky'
+        connection.directories.stubs(:get).returns nil
+
+        connection.directories.expects(:create).
+          with(:key => 'leaky').returns(container)
+
+        syncer.perform!
+      end
+
+      it "iterates over each directory" do
+        syncer.directories << 'files'
+
+        Backup::Syncer::CloudFiles::SyncContext.any_instance.expects(:`).
+          with('find tmp -print0 | xargs -0 openssl md5 2> /dev/null').
+          returns 'MD5(tmp/foo)= 123abcdef'
+        Backup::Syncer::CloudFiles::SyncContext.any_instance.expects(:`).
+          with('find files -print0 | xargs -0 openssl md5 2> /dev/null').
+          returns 'MD5(tmp/foo)= 123abcdef'
+
+        syncer.perform!
+      end
+    end
+
+    context 'file does not exist locally' do
+      let(:file) { stub('file', :key => 'storage/tmp/foo',
+        :etag => '123abcdef') }
+
+      before :each do
+        Backup::Syncer::CloudFiles::SyncContext.any_instance.
+          stubs(:`).returns ''
+        files << file
+        File.stubs(:exist?).returns false
+      end
+
+      it "removes the remote file when mirroring is turned on" do
+        syncer.mirror = true
+
+        file.expects(:destroy).once
+
+        syncer.perform!
+      end
+
+      it "leaves the remote file when mirroring is turned off" do
+        syncer.mirror = false
+
+        file.expects(:destroy).never
+
+        syncer.perform!
+      end
+
+      it "does not remove files not under one of the specified directories" do
+        file.stubs(:key).returns 'unsynced/tmp/foo'
+        syncer.mirror = true
+
+        file.expects(:destroy).never
+
+        syncer.perform!
+      end
+    end
+  end
+end

data/spec/syncer/rsync/base_spec.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+
+require File.expand_path('../../../spec_helper.rb', __FILE__)
+
+describe Backup::Syncer::RSync::Base do
+  let(:syncer) { Backup::Syncer::RSync::Base.new }
+
+  describe '#initialize' do
+
+    it 'should use default values' do
+      syncer.path.should               == 'backups'
+      syncer.directories.should        == []
+      syncer.mirror.should             == false
+      syncer.additional_options.should == []
+    end
+
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Syncer::RSync::Base.clear_defaults! }
+
+      it 'should use the configured defaults' do
+        Backup::Configuration::Syncer::RSync::Base.defaults do |rsync|
+          rsync.path               = 'some_path'
+          #rsync.directories        = 'cannot_have_a_default_value'
+          rsync.mirror             = 'some_mirror'
+          rsync.additional_options = 'some_additional_options'
+        end
+        syncer = Backup::Syncer::RSync::Base.new
+        syncer.path.should               == 'some_path'
+        syncer.directories.should        == []
+        syncer.mirror.should             == 'some_mirror'
+        syncer.additional_options.should == 'some_additional_options'
+      end
+    end
+
+  end # describe '#initialize'
+
+  describe '#directories' do
+    before do
+      syncer.directories = ['/some/directory', '/another/directory']
+    end
+
+    context 'when no block is given' do
+      it 'should return @directories' do
+        syncer.directories.should ==
+            ['/some/directory', '/another/directory']
+      end
+    end
+
+    context 'when a block is given' do
+      it 'should evalute the block, allowing #add to add directories' do
+        syncer.directories do
+          add '/new/path'
+          add '/another/new/path'
+        end
+        syncer.directories.should == [
+          '/some/directory',
+          '/another/directory',
+          '/new/path',
+          '/another/new/path'
+        ]
+      end
+    end
+  end # describe '#directories'
+
+  describe '#add' do
+    before do
+      syncer.directories = ['/some/directory', '/another/directory']
+    end
+
+    it 'should add the given path to @directories' do
+      syncer.add '/my/path'
+      syncer.directories.should ==
+          ['/some/directory', '/another/directory', '/my/path']
+    end
+  end
+
+  describe '#directory_options' do
+    before do
+      syncer.directories = ['/some/directory', '/another/directory']
+    end
+
+    it 'should return the directories for use in the command line' do
+      syncer.send(:directories_option).should ==
+          "'/some/directory' '/another/directory'"
+    end
+
+    it 'should expand relative paths' do
+      syncer.directories += ['relative/path', '~/home/path']
+      syncer.send(:directories_option).should ==
+          "'/some/directory' '/another/directory' " +
+          "'#{ File.expand_path('relative/path') }' " +
+          "'#{ File.expand_path('~/home/path') }'"
+    end
+  end
+
+  describe '#mirror_option' do
+    context 'when @mirror is true' do
+      before { syncer.mirror = true }
+      it 'should return the command line flag for mirroring' do
+        syncer.send(:mirror_option).should == '--delete'
+      end
+    end
+
+    context 'when @mirror is false' do
+      before { syncer.mirror = false }
+      it 'should return nil' do
+        syncer.send(:mirror_option).should be_nil
+      end
+    end
+  end
+
+  describe '#archive_option' do
+    it 'should return the command line flag for archiving' do
+      syncer.send(:archive_option).should == '--archive'
+    end
+  end
+
+end

data/spec/syncer/rsync/local_spec.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+require File.expand_path('../../../spec_helper.rb', __FILE__)
+
+describe Backup::Syncer::RSync::Local do
+  let(:syncer) do
+    Backup::Syncer::RSync::Local.new do |rsync|
+      rsync.path = "~/my_backups"
+
+      rsync.directories do |directory|
+        directory.add "/some/directory"
+        directory.add "~/home/directory"
+      end
+
+      rsync.mirror             = true
+      rsync.additional_options = ['--opt-a', '--opt-b']
+    end
+  end
+
+  it 'should be a subclass of RSync::Base' do
+    Backup::Syncer::RSync::Local.superclass.should == Backup::Syncer::RSync::Base
+  end
+
+  describe '#initialize' do
+    it 'should have defined the configuration properly' do
+      syncer.path.should               == '~/my_backups'
+      syncer.directories.should        == ["/some/directory", "~/home/directory"]
+      syncer.mirror.should             == true
+      syncer.additional_options.should == ['--opt-a', '--opt-b']
+    end
+
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Syncer::RSync::Local.clear_defaults! }
+
+      it 'should override the configured defaults' do
+        Backup::Configuration::Syncer::RSync::Local.defaults do |rsync|
+          rsync.path               = 'old_path'
+          #rsync.directories        = 'cannot_have_a_default_value'
+          rsync.mirror             = 'old_mirror'
+          rsync.additional_options = 'old_additional_options'
+        end
+        syncer = Backup::Syncer::RSync::Local.new do |rsync|
+          rsync.path               = 'new_path'
+          rsync.directories        = 'new_directories'
+          rsync.mirror             = 'new_mirror'
+          rsync.additional_options = 'new_additional_options'
+        end
+
+        syncer.path.should               == 'new_path'
+        syncer.directories.should        == 'new_directories'
+        syncer.mirror.should             == 'new_mirror'
+        syncer.additional_options.should == 'new_additional_options'
+      end
+    end # context 'when setting configuration defaults'
+  end # describe '#initialize'
+
+  describe '#perform!' do
+    let(:s) { sequence '' }
+
+    before do
+      syncer.expects(:utility).with(:rsync).returns('rsync')
+      syncer.expects(:options).returns('options_output')
+    end
+
+    it 'should sync two directories' do
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Syncer::RSync::Local started syncing the following directories:\n" +
+        "  /some/directory\n" +
+        "  ~/home/directory"
+      )
+      syncer.expects(:run).in_sequence(s).with(
+        "rsync options_output '/some/directory' " +
+        "'#{ File.expand_path('~/home/directory') }' " +
+        "'#{ File.expand_path('~/my_backups') }'"
+      ).returns('messages from stdout')
+      Backup::Logger.expects(:silent).in_sequence(s).with('messages from stdout')
+
+      syncer.perform!
+    end
+  end # describe '#perform!'
+
+  describe '#dest_path' do
+    it 'should return @path expanded' do
+      syncer.send(:dest_path).should == File.expand_path('~/my_backups')
+    end
+
+    it 'should set @dest_path' do
+      syncer.send(:dest_path)
+      syncer.instance_variable_get(:@dest_path).should ==
+          File.expand_path('~/my_backups')
+    end
+
+    it 'should return @dest_path if already set' do
+      syncer.instance_variable_set(:@dest_path, 'foo')
+      syncer.send(:dest_path).should == 'foo'
+    end
+  end
+
+  describe '#options' do
+    context 'when @mirror is true' do
+      it 'should return the options with mirroring enabled' do
+        syncer.send(:options).should == '--archive --delete --opt-a --opt-b'
+      end
+    end
+
+    context 'when @mirror is false' do
+      before { syncer.mirror = false }
+      it 'should return the options without mirroring enabled' do
+        syncer.send(:options).should == '--archive --opt-a --opt-b'
+      end
+    end
+
+    context 'when no additional options are given' do
+      before { syncer.additional_options = [] }
+      it 'should return the options without additional options' do
+        syncer.send(:options).should == '--archive --delete'
+      end
+    end
+  end
+
+end

data/spec/syncer/rsync/pull_spec.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require File.expand_path('../../../spec_helper.rb', __FILE__)
+
+describe Backup::Syncer::RSync::Pull do
+  let(:syncer) do
+    Backup::Syncer::RSync::Pull.new do |rsync|
+      rsync.username  = 'my_username'
+      rsync.password  = 'my_password'
+      rsync.ip        = '123.45.678.90'
+      rsync.port      = 22
+      rsync.compress  = true
+      rsync.path      = "~/my_backups"
+
+      rsync.directories do |directory|
+        directory.add "/some/directory"
+        directory.add "~/home/directory"
+      end
+
+      rsync.mirror             = true
+      rsync.additional_options = ['--opt-a', '--opt-b']
+    end
+  end
+
+  it 'should be a subclass of RSync::Push' do
+    Backup::Syncer::RSync::Pull.superclass.should == Backup::Syncer::RSync::Push
+  end
+
+  describe '#perform!' do
+    let(:s) { sequence '' }
+
+    it 'should perform the RSync::Pull operation on two directories' do
+      syncer.expects(:utility).twice.with(:rsync).returns('rsync')
+      syncer.expects(:options).twice.returns('options_output')
+
+      syncer.expects(:write_password_file!).in_sequence(s)
+
+      # first directory
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Syncer::RSync::Pull started syncing '/some/directory'."
+      )
+      syncer.expects(:run).in_sequence(s).with(
+        "rsync options_output 'my_username@123.45.678.90:/some/directory' " +
+        "'#{ File.expand_path('~/my_backups') }'"
+      ).returns('messages from stdout')
+      Backup::Logger.expects(:silent).in_sequence(s).with('messages from stdout')
+
+      # second directory
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Syncer::RSync::Pull started syncing '~/home/directory'."
+      )
+      syncer.expects(:run).in_sequence(s).with(
+        "rsync options_output 'my_username@123.45.678.90:home/directory' " +
+        "'#{ File.expand_path('~/my_backups') }'"
+      ).returns('messages from stdout')
+      Backup::Logger.expects(:silent).in_sequence(s).with('messages from stdout')
+
+      syncer.expects(:remove_password_file!).in_sequence(s)
+
+      syncer.perform!
+    end
+
+    it 'should ensure passoword file removal' do
+      syncer.expects(:write_password_file!).raises('error message')
+      syncer.expects(:remove_password_file!)
+
+      expect do
+        syncer.perform!
+      end.to raise_error(RuntimeError, 'error message')
+    end
+  end # describe '#perform!'
+
+  describe '#dest_path' do
+    it 'should return @path expanded' do
+      syncer.send(:dest_path).should == File.expand_path('~/my_backups')
+    end
+
+    it 'should set @dest_path' do
+      syncer.send(:dest_path)
+      syncer.instance_variable_get(:@dest_path).should ==
+          File.expand_path('~/my_backups')
+    end
+
+    it 'should return @dest_path if already set' do
+      syncer.instance_variable_set(:@dest_path, 'foo')
+      syncer.send(:dest_path).should == 'foo'
+    end
+  end
+
+end