backup 3.0.20 → 3.0.21

data/spec/package_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Package do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:package) { Backup::Package.new(model) }
+
+  before do
+    model.instance_variable_set(:@time, 'model_time')
+  end
+
+  describe '#initialize' do
+    it 'should set all variables' do
+      package.time.should           == 'model_time'
+      package.trigger.should        == 'test_trigger'
+      package.extension.should      == 'tar'
+      package.chunk_suffixes.should == []
+      package.version.should        == Backup::Version.current
+    end
+  end
+
+  describe '#filenames' do
+    context 'when the package files were not split' do
+      it 'should return an array with the single package filename' do
+        package.filenames.should == ['model_time.test_trigger.tar']
+      end
+
+      it 'should reflect changes in the extension' do
+        package.extension << '.enc'
+        package.filenames.should == ['model_time.test_trigger.tar.enc']
+      end
+    end
+
+    context 'when the package files were split' do
+      before { package.chunk_suffixes = ['aa', 'ab'] }
+      it 'should return an array of the package filenames' do
+        package.filenames.should == ['model_time.test_trigger.tar-aa',
+                                     'model_time.test_trigger.tar-ab']
+      end
+
+      it 'should reflect changes in the extension' do
+        package.extension << '.enc'
+        package.filenames.should == ['model_time.test_trigger.tar.enc-aa',
+                                     'model_time.test_trigger.tar.enc-ab']
+      end
+    end
+  end
+
+  describe '#basename' do
+    it 'should return the base filename for the package' do
+      package.basename.should == 'model_time.test_trigger.tar'
+    end
+
+    it 'should reflect changes in the extension' do
+      package.extension << '.enc'
+      package.basename.should == 'model_time.test_trigger.tar.enc'
+    end
+  end
+
+end

data/spec/packager_spec.rb

@@ -0,0 +1,154 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe 'Backup::Packager' do
+  let(:packager)  { Backup::Packager }
+
+  describe '#package!' do
+    let(:model)     { mock }
+    let(:package)   { mock }
+    let(:encryptor) { mock }
+    let(:splitter)  { mock }
+    let(:procedure) { mock }
+    let(:s)         { sequence '' }
+
+    it 'should setup variables and perform packaging procedures' do
+      model.expects(:package).in_sequence(s).returns(package)
+      model.expects(:encryptor).in_sequence(s).returns(encryptor)
+      model.expects(:splitter).in_sequence(s).returns(splitter)
+
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        'Packaging the backup files...'
+      )
+      packager.expects(:procedure).in_sequence(s).returns(procedure)
+      procedure.expects(:call).in_sequence(s)
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        'Packaging Complete!'
+      )
+
+      packager.package!(model)
+
+      packager.instance_variable_get(:@package).should be(package)
+      packager.instance_variable_get(:@encryptor).should be(encryptor)
+      packager.instance_variable_get(:@splitter).should be(splitter)
+    end
+  end # describe '#package!'
+
+  describe '#procedure' do
+
+    module Fake
+      def self.stack_trace
+        @stack ||= []
+      end
+      class Encryptor
+        def encrypt_with
+          Fake.stack_trace << :encryptor_before
+          yield 'encryption_command', '.enc'
+          Fake.stack_trace << :encryptor_after
+        end
+      end
+      class Splitter
+        def split_with
+          Fake.stack_trace << :splitter_before
+          yield 'splitter_command'
+          Fake.stack_trace << :splitter_after
+        end
+      end
+      class Package
+        attr_accessor :trigger, :extension
+        def basename
+          'base_filename.' + extension
+        end
+      end
+    end
+
+    let(:package)   { Fake::Package.new }
+    let(:encryptor) { Fake::Encryptor.new }
+    let(:splitter)  { Fake::Splitter.new }
+
+    before do
+      Fake.stack_trace.clear
+      packager.expects(:utility).with(:tar).returns('tar')
+      packager.instance_variable_set(:@package, package)
+      package.trigger = 'model_trigger'
+      package.extension = 'tar'
+    end
+
+    context 'when no encryptor or splitter are defined' do
+      it 'should package the backup without encryption into a single file' do
+        packager.instance_variable_set(:@encryptor, nil)
+        packager.instance_variable_set(:@splitter,  nil)
+
+        packager.expects(:run).with(
+          "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'" +
+          " > #{ File.join(Backup::Config.tmp_path, 'base_filename.tar') }"
+        )
+        packager.send(:procedure).call
+      end
+    end
+
+    context 'when only an encryptor is configured' do
+      it 'should package the backup with encryption' do
+        packager.instance_variable_set(:@encryptor, encryptor)
+        packager.instance_variable_set(:@splitter,  nil)
+
+        packager.expects(:run).with do |command|
+          Fake.stack_trace << :command_executed
+          command.should ==
+            "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'" +
+            " | encryption_command" +
+            " > #{ File.join(Backup::Config.tmp_path, 'base_filename.tar.enc') }"
+        end
+        packager.send(:procedure).call
+
+        Fake.stack_trace.should == [
+          :encryptor_before, :command_executed, :encryptor_after
+        ]
+      end
+    end
+
+    context 'when only a splitter is configured' do
+      it 'should package the backup without encryption through the splitter' do
+        packager.instance_variable_set(:@encryptor, nil)
+        packager.instance_variable_set(:@splitter,  splitter)
+
+        packager.expects(:run).with do |command|
+          Fake.stack_trace << :command_executed
+          command.should ==
+            "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'" +
+            " | splitter_command"
+        end
+        packager.send(:procedure).call
+
+        Fake.stack_trace.should == [
+          :splitter_before, :command_executed, :splitter_after
+        ]
+      end
+    end
+
+    context 'when both an encryptor and a splitter are configured' do
+      it 'should package the backup with encryption through the splitter' do
+        packager.instance_variable_set(:@encryptor, encryptor)
+        packager.instance_variable_set(:@splitter,  splitter)
+
+        packager.expects(:run).with do |command|
+          Fake.stack_trace << :command_executed
+          command.should ==
+            "tar -cf - -C '#{ Backup::Config.tmp_path }' 'model_trigger'" +
+            " | encryption_command | splitter_command"
+        end
+        packager.send(:procedure).call
+
+        Fake.stack_trace.should == [
+          :encryptor_before, :splitter_before,
+          :command_executed,
+          :splitter_after, :encryptor_after
+        ]
+        package.extension.should == 'tar.enc'
+      end
+    end
+
+  end # describe '#procedure'
+
+end

data/spec/spec_helper.rb

@@ -9,28 +9,51 @@ require 'bundler/setup'
 # Load Backup
 require 'backup'
 
-##
-# Use Mocha to mock with RSpec
-require 'rspec'
+require 'timecop'
+
+module Backup::ExampleHelpers
+  # ripped from MiniTest :)
+  # RSpec doesn't have a method for this? Am I missing something?
+  def capture_io
+    require 'stringio'
+
+    orig_stdout, orig_stderr = $stdout, $stderr
+    captured_stdout, captured_stderr = StringIO.new, StringIO.new
+    $stdout, $stderr = captured_stdout, captured_stderr
+
+    yield
+
+    return captured_stdout.string, captured_stderr.string
+  ensure
+    $stdout = orig_stdout
+    $stderr = orig_stderr
+  end
+end
+
+require 'rspec/autorun'
 RSpec.configure do |config|
+  ##
+  # Use Mocha to mock with RSpec
   config.mock_with :mocha
+
+  ##
+  # Example Helpers
+  config.include Backup::ExampleHelpers
+
+  ##
+  # Actions to perform before each example
   config.before(:each) do
-    FileUtils.stubs(:mkdir_p)
+    FileUtils.collect_method(:noop).each do |method|
+      FileUtils.stubs(method).raises("Unexpected call to FileUtils.#{method}")
+    end
+    Open4.stubs(:popen4).raises('Unexpected call to CLI::Helpers.run()')
+
     [:message, :error, :warn, :normal, :silent].each do |message_type|
       Backup::Logger.stubs(message_type)
     end
-    Backup::Model.extension = 'tar'
   end
 end
 
-Backup.send(:remove_const, :TRIGGER) if defined? Backup::TRIGGER
-Backup.send(:remove_const, :TIME) if defined? Backup::TIME
-
-module Backup
-  TRIGGER = 'myapp'
-  TIME = Time.now.strftime("%Y.%m.%d.%H.%M.%S")
-end
-
 unless @_put_ruby_version
   puts @_put_ruby_version = "\n\nRuby version: #{RUBY_DESCRIPTION}\n\n"
 end

data/spec/splitter_spec.rb

@@ -3,69 +3,118 @@
 require File.expand_path('../spec_helper.rb', __FILE__)
 
 describe Backup::Splitter do
-  let(:model)    { mock("Backup::Model")       }
-  let(:splitter) { Backup::Splitter.new(model) }
-
-  before do
-    splitter.stubs(:chunks).returns([
-      "/some/file.tar.gz.enc-ad",
-      "/some/file.tar.gz.enc-ac",
-      "/some/file.tar.gz.enc-ab",
-      "/some/file.tar.gz.enc-aa",
-    ])
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:splitter) { Backup::Splitter.new(model, 250) }
+  let(:package) { mock }
+
+  describe '#initialize' do
+    it 'should set instance variables' do
+      splitter.instance_variable_get(:@model).should be(model)
+      splitter.instance_variable_get(:@chunk_size).should be(250)
+    end
   end
 
-  describe "#chunk_suffixes" do
-    it "should return an array of chunk suffixes (ordered in alphabetical order)" do
-      splitter.send(:chunk_suffixes).should == ["aa", "ab", "ac", "ad"]
+  describe '#split_with' do
+    it 'should yield the split command, performing before/after methods' do
+      s = sequence ''
+      given_block = mock
+      block = lambda {|arg| given_block.got(arg) }
+      splitter.instance_variable_set(:@split_command, 'split command')
+
+      splitter.expects(:before_packaging).in_sequence(s)
+      given_block.expects(:got).in_sequence(s).with('split command')
+      splitter.expects(:after_packaging).in_sequence(s)
+
+      splitter.split_with(&block)
     end
   end
 
-  describe "#bytes_representation_of" do
-    it "should convert megabytes to bytes" do
-      splitter.send(:bytes_representation_of, 50).should == 52428800
+  # Note: using a 'M' suffix for the byte size is not OSX compatible
+  describe '#before_packaging' do
+    before do
+      model.instance_variable_set(:@package, package)
+      splitter.expects(:utility).with(:split).returns('split')
+      package.expects(:basename).returns('base_filename')
+    end
+
+    it 'should set @package and @split_command' do
+      Backup::Logger.expects(:message).with(
+        'Splitter configured with a chunk size of 250MB.'
+      )
+      splitter.send(:before_packaging)
+
+      splitter.instance_variable_get(:@package).should be(package)
+
+      split_suffix = File.join(Backup::Config.tmp_path, 'base_filename-')
+      splitter.instance_variable_get(:@split_command).should ==
+          "split -b 250m - '#{ split_suffix }'"
     end
   end
 
-  describe "#split!" do
+  describe '#after_packaging' do
     before do
-      model.stubs(:file).returns("/some/file.tar.gz.enc")
+      splitter.instance_variable_set(:@package, package)
     end
 
-    [nil, true, false, "123", :sym].each do |value|
-      it "should not split: chunk_size must be an integer" do
-        model.stubs(:chunk_size).returns(value)
+    context 'when splitting occurred during packaging' do
+      before do
+        splitter.expects(:chunk_suffixes).returns(['aa', 'ab'])
+      end
 
-        File.expects(:size).never
-        splitter.expects(:bytes_representation_of).never
-        splitter.expects(:run).never
-        splitter.split!
+      it 'should set the chunk_suffixes for the package' do
+        package.expects(:chunk_suffixes=).with(['aa', 'ab'])
+        splitter.send(:after_packaging)
       end
     end
 
-    it "should not split: chunk size is 300mb, file is 300mb" do
-      File.expects(:size).with(model.file).returns(52428800) # 300mb
-      model.stubs(:chunk_size).returns(300)
+    context 'when splitting did not occur during packaging' do
+      before do
+        splitter.expects(:chunk_suffixes).returns(['aa'])
+        package.expects(:basename).twice.returns('base_filename')
+      end
 
-      splitter.expects(:run).never
-      splitter.split!
+      it 'should remove the suffix from the only package file' do
+        package.expects(:chunk_suffixes=).never
+        FileUtils.expects(:mv).with(
+          File.join(Backup::Config.tmp_path, 'base_filename-aa'),
+          File.join(Backup::Config.tmp_path, 'base_filename')
+        )
+        splitter.send(:after_packaging)
+      end
+    end
+  end # describe '#after_packaging'
+
+  describe '#chunk_suffixes' do
+    before do
+      splitter.expects(:chunks).returns(
+        ['/path/to/file.tar-aa', '/path/to/file.tar-ab']
+      )
     end
 
-    it "should not split: chunk size is 300mb, file size is 200mb" do
-      File.expects(:size).with(model.file).returns(209715200) # 200mb
-      model.stubs(:chunk_size).returns(300)
+    it 'should return an array of chunk suffixes' do
+      splitter.send(:chunk_suffixes).should == ['aa', 'ab']
+    end
+  end
 
-      splitter.expects(:run).never
-      splitter.split!
+  describe '#chunks' do
+    before do
+      splitter.instance_variable_set(:@package, package)
+      package.expects(:basename).returns('base_filename')
+      FileUtils.unstub(:touch)
     end
 
-    it "should split: chunk size is 300mb, file size is 400mb" do
-      File.expects(:size).with(model.file).returns(419430400) # 400mb
-      model.stubs(:chunk_size).returns(300)
+    it 'should return a sorted array of chunked file paths' do
+      Dir.mktmpdir do |dir|
+        Backup::Config.expects(:tmp_path).returns(dir)
+        FileUtils.touch(File.join(dir, 'base_filename-aa'))
+        FileUtils.touch(File.join(dir, 'base_filename-ab'))
 
-      splitter.expects(:utility).with(:split).returns("split")
-      splitter.expects(:run).with("split -b 300m '/some/file.tar.gz.enc' '/some/file.tar.gz.enc-'")
-      splitter.split!
+        splitter.send(:chunks).should == [
+          File.join(dir, 'base_filename-aa'),
+          File.join(dir, 'base_filename-ab')
+        ]
+      end
     end
   end
+
 end

data/spec/storage/base_spec.rb

@@ -3,288 +3,144 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Storage::Base do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:package) { mock }
+  let(:base)    { Backup::Storage::Base.new(model) }
 
   describe '#initialize' do
-
-    after do
-      Backup::Configuration::Storage::Base.clear_defaults!
-    end
-
-    it 'should create a new storage object with default values' do
-      base = Backup::Storage::Base.new
+    it 'should set instance variables' do
+      base.instance_variable_get(:@model).should be(model)
+      base.instance_variable_defined?(:@storage_id).should be_true
+      base.instance_variable_get(:@storage_id).should be_nil
       base.keep.should be_nil
-      base.time.should == Backup::TIME
     end
 
-    it 'should set configured defaults' do
-      Backup::Configuration::Storage::Base.defaults do |base|
-        base.keep = 5
+    context 'when given a storage_id' do
+      it 'should set @storage_id' do
+        base = Backup::Storage::Base.new(model, 'my storage id')
+        base.instance_variable_get(:@storage_id).should == 'my storage id'
       end
-
-      base = Backup::Storage::Base.new
-      base.keep.should == 5
-      base.time.should == Backup::TIME
     end
 
-    it 'should override the configuration defaults with the configure block' do
-      Backup::Configuration::Storage::Base.defaults do |base|
-        base.keep = 5
-      end
-
-      base = Backup::Storage::Base.new do |base|
-        base.keep = 10
+    context 'when configuration defaults are set' do
+      after { Backup::Configuration::Storage::Base.clear_defaults! }
+      it 'should use the defaults' do
+        Backup::Configuration::Storage::Base.defaults do |base|
+          base.keep = 5
+        end
+        base = Backup::Storage::Base.new(model)
+        base.keep.should be(5)
       end
-      base.keep.should == 10
-      base.time.should == Backup::TIME
     end
+  end # describe '#initialize'
 
-    it 'should store the configuration block' do
-      config_block = lambda {|base| base.keep = 10 }
-      base = Backup::Storage::Base.new(&config_block)
+  describe '#perform!' do
+    before do
+      model.instance_variable_set(:@package, package)
+    end
 
-      base.keep.should == 10
-      base.configure_block.should be config_block
+    it 'should call #transfer!, then #cycle!' do
+      s = sequence ''
+      base.expects(:transfer!).in_sequence(s)
+      base.expects(:cycle!).in_sequence(s)
+      base.perform!
+      base.instance_variable_get(:@package).should be(package)
     end
+  end
 
-    it 'should set the storage_id using an optional block parameter' do
-      base = Backup::Storage::Base.new('my storage_id') do |base|
-        base.keep = 10
+  describe '#storage_name' do
+    context 'when given a storage_id' do
+      before { base.storage_id = 'storage id' }
+      it 'should return a log-friendly name with the storage_id' do
+        base.send(:storage_name).should == 'Storage::Base (storage id)'
       end
-      base.keep.should == 10
-      base.time.should == Backup::TIME
-      base.storage_id.should == 'my storage_id'
     end
 
-  end # describe '#inititalize'
-
-  describe '#clean!' do
-
-    context 'when clearing instance variables for cycling' do
-      it 'version stamps the object' do
-        cycle_required_variables = %w[ @filename @time @chunk_suffixes ]
-        expected_variables = (cycle_required_variables + ['@version']).sort
-
-        base = Backup::Storage::Base.new do |config|
-          config.storage_id = 'bar_id'
-          config.keep = 3
-        end
-        base.time = Time.utc(2011, 12, 2)
-        base.chunk_suffixes = ['aa', 'ab']
-        base.instance_variable_set(:@filename, 'foo.tar')
-        base.version.should be_nil
-
-        base.send(:clean!)
-        base.instance_variables.map(&:to_s).sort.should == expected_variables
-        base.time.should == Time.utc(2011, 12, 2)
-        base.chunk_suffixes.should == ['aa', 'ab']
-        base.filename.should == 'foo.tar'
-        base.version.should == Backup::Version.current
+    context 'when not given a storage_id' do
+      it 'should return a log-friendly name without a storage_id' do
+        base.send(:storage_name).should == 'Storage::Base'
       end
     end
-
   end
 
-  describe '#update!' do
+  describe '#local_path' do
+    it 'should return the configured tmp_path' do
+      base.send(:local_path).should == Backup::Config.tmp_path
+    end
+  end
 
-    it 'updates the storage object with the given configure_block' do
-      base_a = Backup::Storage::Base.new do |config|
-        config.storage_id = 'foo_id'
-        config.keep = 5
-      end
-      base_b = Backup::Storage::Base.new do |config|
-        config.storage_id = 'bar_id'
-        config.keep = 3
-      end
-      base_b.expects(:upgrade_if_needed!)
+  describe '#remote_path_for' do
+    before do
+      package.expects(:trigger).returns('test_trigger')
+      package.expects(:time).returns('backup_time')
+      base.expects(:path).returns('base/remote/path')
+    end
 
-      base_b.send(:update!, base_a.configure_block)
-      base_b.storage_id.should == 'foo_id'
-      base_b.keep.should == 5
+    it 'should return the remote_path for the given package' do
+      base.send(:remote_path_for, package).should ==
+          File.join('base/remote/path', 'test_trigger', 'backup_time')
     end
+  end
 
-    it 'updates YAML loaded objects, which were `cleaned` for cycling' do
-      base = Backup::Storage::Base.new do |config|
-        config.storage_id = 'foo_id'
-        config.keep = 5
-      end
-      base.time.should == Backup::TIME
+  describe '#files_to_transfer_for' do
+    let(:given_block) { mock }
+    before do
+      package.stubs(:filenames).returns(
+        ['2011.12.31.11.00.02.backup.tar.enc-aa',
+         '2011.12.31.11.00.02.backup.tar.enc-ab']
+      )
+    end
 
-      loaded = Backup::Storage::Base.new do |config|
-        config.storage_id = 'bar_id'
-        config.keep = 3
+    it 'should yield the full filename and the filename without the timestamp' do
+      given_block.expects(:got).with(
+        '2011.12.31.11.00.02.backup.tar.enc-aa', 'backup.tar.enc-aa'
+      )
+      given_block.expects(:got).with(
+        '2011.12.31.11.00.02.backup.tar.enc-ab', 'backup.tar.enc-ab'
+      )
+      base.send(:files_to_transfer_for, package) do |local_file, remote_file|
+        given_block.got(local_file, remote_file)
       end
-      loaded.time = Time.utc(2011, 12, 2)
-      loaded.chunk_suffixes = ['aa', 'ab']
-      loaded.instance_variable_set(:@filename, 'foo.tar')
-
-      loaded.send(:clean!)
-      loaded.storage_id.should == nil
-      loaded.keep.should == nil
-      loaded.version.should == Backup::Version.current
-
-      loaded.send(:update!, base.configure_block)
-      loaded.storage_id.should == 'foo_id'
-      loaded.keep.should == 5
-      loaded.time.should == Time.utc(2011, 12, 2)
-      loaded.chunk_suffixes.should == ['aa', 'ab']
-      loaded.filename.should == 'foo.tar'
-      loaded.version.should == Backup::Version.current
     end
 
-  end # describe '#update!'
-
-  describe '#upgrade_if_needed!' do
-
-    it 'upgrades <= 3.0.19' do
-      v_3_0_19_yaml = <<-EOF.gsub(/^\s+/,'  ').gsub(/^  -/,'-')
-        ---
-        !ruby/object:Backup::Storage::SCP
-        username: a_user
-        password: a_password
-        ip: an_address
-        port: a_port
-        path: a_path
-        keep: a_few
-        time: 2011.11.01.01.02.03
-        local_file: 2011.11.01.01.02.03.a_backup.tar
-        remote_file: 2011.11.01.01.02.03.a_backup.tar
-      EOF
-      loaded = YAML.load(v_3_0_19_yaml)
-      cycle_required_variables = %w[ @filename @time @chunk_suffixes ]
-      expected_variables = (cycle_required_variables + ['@version']).sort
-
-      loaded.send(:upgrade_if_needed!)
-      loaded.instance_variables.map(&:to_s).sort.should == expected_variables
-      loaded.filename.should == '2011.11.01.01.02.03.a_backup.tar'
-      loaded.time.should == '2011.11.01.01.02.03'
-      loaded.chunk_suffixes.should == []
-      loaded.version.should == Backup::Version.current
+    it 'should have an alias method called #transferred_files_for' do
+      base.method(:transferred_files_for).should ==
+          base.method(:files_to_transfer_for)
     end
-
-  end # describe '#upgrade_if_needed!'
+  end
 
   describe '#cycle!' do
-    let(:base) { Backup::Storage::Base.new {} }
-
-    it 'updates loaded objects and adds current object' do
-      s = sequence ''
-      storage_object = mock
-      loaded_object = mock
-
-      Backup::Storage::Object.expects(:new).in_sequence(s).
-          with('Base', nil).returns(storage_object)
-      storage_object.expects(:load).in_sequence(s).
-          returns([loaded_object])
-      loaded_object.expects(:update!).in_sequence(s).
-          with(base.configure_block)
-      objects = [base, loaded_object]
-      objects.each {|object| object.expects(:clean!).in_sequence(s) }
-      storage_object.expects(:write).in_sequence(s).
-          with(objects)
-
-      base.keep = 2
-      base.send(:cycle!)
+    before do
+      base.stubs(:storage_name).returns('Storage Name')
+      base.instance_variable_set(:@package, package)
     end
 
-    context 'when removing old stored objects' do
-
-      it 'should warn and continue on errors' do
-        num_to_load = 6
-        num_to_keep = 3
-        obj_to_fail = 2 # we're removing 3, so fail the 2nd one.
-
+    context 'when keep is set and > 0' do
+      before { base.keep = 1 }
+      it 'should cycle' do
         s = sequence ''
-        storage_object = mock
-        raised_error = StandardError.new
-        loaded_objects = []
-        (1..num_to_load).each do |n|
-          instance_eval <<-EOS
-            loaded_object#{n} = mock
-            loaded_object#{n}.stubs(:filename).returns("file#{n}")
-            loaded_objects << loaded_object#{n}
-          EOS
-        end
+        Backup::Logger.expects(:message).in_sequence(s).
+            with('Storage Name: Cycling Started...')
+        Backup::Storage::Cycler.expects(:cycle!).in_sequence(s).
+            with(base, package)
+        Backup::Logger.expects(:message).in_sequence(s).
+            with('Storage Name: Cycling Complete!')
 
-        Backup::Storage::Object.expects(:new).in_sequence(s).
-            with('Base', nil).returns(storage_object)
-        storage_object.expects(:load).in_sequence(s).
-            returns(loaded_objects)
-        loaded_objects.each do |loaded_object|
-          loaded_object.expects(:update!).in_sequence(s).
-              with(base.configure_block)
-        end
-        objects = [base] + loaded_objects
-
-        objects_to_remove = objects[num_to_keep..-1]
-        objects_to_remove.each_with_index do |object_to_remove, i|
-          Backup::Logger.expects(:message).in_sequence(s).
-              with {|msg| msg.include?(object_to_remove.filename) }
-          if i == obj_to_fail
-            object_to_remove.expects(:remove!).in_sequence(s).
-                raises(raised_error)
-            Backup::Errors::Storage::CycleError.expects(:wrap).in_sequence(s).
-                with(raised_error, "#{base.storage_name} failed to remove " +
-                    "'#{object_to_remove.filename}'").
-                returns(:wrapped_error)
-            Backup::Logger.expects(:warn).in_sequence(s).
-                with(:wrapped_error)
-          else
-            object_to_remove.expects(:remove!).in_sequence(s)
-          end
-        end
-
-        objects = objects - objects_to_remove
-        objects.each {|object| object.expects(:clean!).in_sequence(s) }
-        storage_object.expects(:write).in_sequence(s).
-            with(objects)
-
-        base.keep = num_to_keep
         base.send(:cycle!)
       end
-
     end
 
-  end
-
-  describe '#chunks' do
-
-    it 'returns sorted filenames for chunk_suffixes' do
-      base = Backup::Storage::Base.new
-      base.chunk_suffixes = ["aa", "ad", "ae", "ab", "ac"]
-      base.stubs(:filename).returns("file.tar")
-      base.chunks.should == [
-        "#{base.filename}-aa",
-        "#{base.filename}-ab",
-        "#{base.filename}-ac",
-        "#{base.filename}-ad",
-        "#{base.filename}-ae",
-      ]
-
-      base.chunk_suffixes.should == ["aa", "ad", "ae", "ab", "ac"]
-    end
-
-  end
-
-  describe '#storage_name' do
-    let(:s3) { Backup::Storage::S3.new {} }
-
-    describe 'returns storage class name with the Backup:: namespace removed' do
-
-      context 'when storage_id is set' do
-        before { s3.storage_id = 'my storage' }
-
-        it 'appends the storage_id' do
-          s3.storage_name.should == 'Storage::S3 (my storage)'
-        end
+    context 'when keep is not set or == 0' do
+      it 'should return nil when not set' do
+        base.keep = nil
+        base.send(:cycle!).should be_nil
       end
 
-      context 'when storage_id is not set' do
-        it 'does not append the storage_id' do
-          s3.storage_name.should == 'Storage::S3'
-        end
+      it 'should return nil when == 0' do
+        base.keep = 0
+        base.send(:cycle!).should be_nil
       end
-
     end
-
   end
+
 end