awshucks 0.0.1

data/spec/commands/restore_spec.rb

@@ -0,0 +1,219 @@
+require File.join(File.dirname(__FILE__),"..","spec_helper.rb")
+
+describe Awshucks::RestoreCommand do
+  it "has 'restore' as the command" do
+    Awshucks::RestoreCommand.command.should == 'restore'
+  end
+end
+
+describe Awshucks::RestoreCommand, '#execute, with no backup configuration specified' do
+  
+  before(:each) do
+    @config = mock('config')
+    @restore = Awshucks::RestoreCommand.new
+    @old_stderr, $stderr = $stderr, StringIO.new
+  end
+  
+  after(:each) do
+    $stderr = @old_stderr
+  end
+  
+  it "prints out an error" do
+    @restore.execute([], @config)
+    $stderr.string.should =~ /specify a backup/i
+  end
+  
+end
+
+describe Awshucks::RestoreCommand, '#execute, with just a backup configuration specified' do
+
+  before(:each) do
+    @connection = mock('connection')
+    
+    @backup = mock('backup configuration')
+    @backup.stub!(:name).and_return('testbackup')
+    @backup.stub!(:location).and_return('/test/location')
+    
+    @config = mock('config')
+    @config.stub!(:connection).and_return(@connection)
+    @config.stub!(:backup).and_return(@backup)
+
+    @config.stub!(:bucket).and_return('testbucket')
+    @restore = Awshucks::RestoreCommand.new
+    @old_stderr, $stderr = $stderr, StringIO.new
+    @old_stdout, $stdout = $stdout, StringIO.new
+    
+    @file_store = mock(Awshucks::FileStore)
+  end
+  
+  after(:each) do
+    $stderr = @old_stderr
+    $stdout = @old_stdout
+  end
+  
+  it "instantiates a FileStore object for the backup config" do
+    Awshucks::FileStore.should_receive(:new).with(@connection, 'testbucket', 'testbackup').and_return(@file_store)
+    @file_store.stub!(:each_file)
+    @restore.execute(['testbackup'], @config)
+  end
+  
+  it "iterates through each file in the file store and calls restore on each entry" do
+    Awshucks::FileStore.should_receive(:new).with(@connection, 'testbucket', 'testbackup').and_return(@file_store)
+    @file_store.should_receive(:each_file).and_yield('file')
+    @file_store.should_receive(:restore).with('file', '/test/location/file')
+    
+    @restore.execute(['testbackup'], @config)
+  end
+  
+  it "prints a warning if the backup config isn't found" do
+    @config.stub!(:backup).and_raise(Awshucks::UnknownBackupError.new('foo'))
+    @restore.execute(['foo'], @config)
+  end
+
+end
+
+describe Awshucks::RestoreCommand, '#execute, with a backup configuration and a specific file' do
+
+  before(:each) do
+    @connection = mock('connection')
+    
+    @backup = mock('backup configuration')
+    @backup.stub!(:name).and_return('testbackup')
+    @backup.stub!(:location).and_return('/test/location')
+    
+    @config = mock('config')
+    @config.stub!(:connection).and_return(@connection)
+    @config.stub!(:backup).and_return(@backup)
+
+    @config.stub!(:bucket).and_return('testbucket')
+    @restore = Awshucks::RestoreCommand.new
+
+    @old_stdout, $stdout = $stdout, StringIO.new
+
+    @file_store = mock(Awshucks::FileStore)
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+  end
+  
+  it "iterates through each file in the file store and calls restore on each entry" do
+    Awshucks::FileStore.should_receive(:new).with(@connection, 'testbucket', 'testbackup').and_return(@file_store)
+    class << @file_store
+      def each_file
+        yield 'other_file'
+        yield 'specific_file'
+        yield 'another/file'
+      end
+    end
+
+    @file_store.should_receive(:restore).with('specific_file', '/test/location/specific_file')
+    
+    @restore.execute(['testbackup', 'specific_file'], @config)
+  end
+  
+end
+
+describe Awshucks::RestoreCommand, '#execute, with a backup configuration and a pattern' do
+
+  before(:each) do
+    @connection = mock('connection')
+    
+    @backup = mock('backup configuration')
+    @backup.stub!(:name).and_return('testbackup')
+    @backup.stub!(:location).and_return('/test/location')
+    
+    @config = mock('config')
+    @config.stub!(:connection).and_return(@connection)
+    @config.stub!(:backup).and_return(@backup)
+
+    @config.stub!(:bucket).and_return('testbucket')
+    @restore = Awshucks::RestoreCommand.new
+
+    @old_stdout, $stdout = $stdout, StringIO.new
+    
+    @file_store = mock(Awshucks::FileStore)
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+  end
+  
+  it "restores all files when the pattern is '*'" do
+    Awshucks::FileStore.should_receive(:new).with(@connection, 'testbucket', 'testbackup').and_return(@file_store)
+    class << @file_store
+      def each_file
+        yield 'some_file'
+        yield 'another/file'
+      end
+    end
+
+    @file_store.should_receive(:restore).with('some_file', '/test/location/some_file')
+    @file_store.should_receive(:restore).with('another/file', '/test/location/another/file')
+    
+    @restore.execute(['testbackup', '*'], @config)
+  end
+  
+  it "restores only the files matching the pattern" do
+    Awshucks::FileStore.should_receive(:new).with(@connection, 'testbucket', 'testbackup').and_return(@file_store)
+    class << @file_store
+      def each_file
+        yield 'some_file'
+        yield 'sub/file'
+        yield 'foo/bar'
+      end
+    end
+
+    @file_store.should_receive(:restore).with('some_file', '/test/location/some_file')
+    @file_store.should_receive(:restore).with('foo/bar', '/test/location/foo/bar')
+    
+    @restore.execute(['testbackup', '*o*'], @config)
+  end
+
+end
+
+describe Awshucks::RestoreCommand, '#execute, with a backup, pattern, and a target directory' do
+
+  before(:each) do
+    @connection = mock('connection')
+    
+    @backup = mock('backup configuration')
+    @backup.stub!(:name).and_return('testbackup')
+    @backup.stub!(:location).and_return('/test/location')
+    
+    @config = mock('config')
+    @config.stub!(:connection).and_return(@connection)
+    @config.stub!(:backup).and_return(@backup)
+
+    @config.stub!(:bucket).and_return('testbucket')
+    @restore = Awshucks::RestoreCommand.new
+
+    @old_stdout, $stdout = $stdout, StringIO.new
+    
+    @file_store = mock(Awshucks::FileStore)
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+  end
+  
+  it "calls restore using the target directory as the base directory for the restore" do
+    Awshucks::FileStore.should_receive(:new).with(@connection, 'testbucket', 'testbackup').and_return(@file_store)
+    @file_store.should_receive(:each_file).and_yield('test/file')
+
+    @file_store.should_receive(:restore).with('test/file', '/another/place/test/file')
+    
+    @restore.execute(['testbackup', '*', '/another/place'], @config)
+  end
+  
+  it "calls restore with the target being a fully expanded path" do
+    Awshucks::FileStore.stub!(:new).and_return(@file_store)
+    @file_store.stub!(:each_file).and_yield('test/file')
+
+    @file_store.should_receive(:restore).with('test/file', '/full/path/another/place/test/file')
+    
+    File.should_receive(:expand_path).with('another/place').and_return('/full/path/another/place')
+    @restore.execute(['testbackup', '*', 'another/place'], @config)
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,152 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+
+describe Awshucks::Config do
+  
+  before(:each) do
+    @old_stderr, $stderr = $stderr, StringIO.new
+  end
+  
+  after(:each) do
+    $stderr = @old_stderr
+  end
+  
+  it "accepts a filename as a parameter to initialize" do
+    config = Awshucks::Config.new( fixture_file('awshucks.yml') )
+  end  
+  
+  it "lazily loads the yaml file" do
+    config = Awshucks::Config.new( fixture_file('awshucks.yml') )
+    # YAML.should_receive(:load).and_return({})
+    # config.send(:config) # force the lazy load
+    config.connection.should == {
+      :access_key_id => "access key",
+      :secret_access_key => 'secret access key',
+      :persistent => false,
+      :use_ssl => true
+    }  
+  end
+  
+  it "prints an error and exits if the config file wasn't found" do
+    config = Awshucks::Config.new( fixture_file('awshucks.yml') )
+    YAML.should_receive(:load).and_raise(Errno::ENOENT)
+    lambda { config.send(:config) }.should raise_error(SystemExit)
+    $stderr.string.should =~ /not found/
+  end
+  
+end
+
+# describe Awshucks::Config, '.load' do
+#   
+#   before(:each) do
+#     @config = Awshucks::Config.load(fixture_file('awshucks.yml'))
+#   end
+#   
+#   it "should load the specified file as YAML" do
+#     @config.connection.should == {
+#       :access_key_id => "access key",
+#       :secret_access_key => 'secret access key',
+#       :persistent => false,
+#       :use_ssl => true
+#     }
+#   end
+#   
+#   it "should return a Config object" do
+#     @config.should be_instance_of(Awshucks::Config)
+#   end
+# end
+
+describe Awshucks::Config, '#connection' do
+  
+  it "should return the connection info specified in the config file, appropriate for the AWS library" do
+    config = Awshucks::Config.new(fixture_file('awshucks.yml'))
+    config.connection.should == {
+      :access_key_id => "access key",
+      :secret_access_key => 'secret access key',
+      :persistent => false,
+      :use_ssl => true
+    }
+  end
+  
+  Awshucks::Config::REQUIRED_CONNECTION_KEYS.each do |key|
+    it "should raise an exception if the config file is missing the #{key} connection option" do
+      data = YAML.load(fixture_file('awshucks.yml'))
+      data.delete(key)
+      File.stub!(:open)
+      YAML.should_receive(:load).and_return(data)
+      config = Awshucks::Config.new('lol')
+      lambda { config.connection }.should raise_error(Awshucks::RequiredConfigError)
+    end
+  end  
+  
+end
+
+describe Awshucks::Config, '#bucket' do
+  before(:each) do
+    @config = Awshucks::Config.new(fixture_file('awshucks.yml'))
+  end
+
+  it "should return the configured bucket name" do
+    @config.bucket.should == "testbucket"
+  end
+
+end
+
+describe Awshucks::Config, '#backup' do
+  before(:each) do
+    @config = Awshucks::Config.new(fixture_file('awshucks.yml'))
+  end
+  
+  it "should return the information for a specific backup location" do
+    @config.backup('test_backup').should_not be_nil
+  end
+  
+  it "should return an object with a location attribute" do
+    @config.backup('test_backup').location.should == '/primary/backup'
+  end
+  
+  it "should return an object with a name attribute" do
+    @config.backup('test_backup').name.should == 'test_backup'
+  end
+  
+  Awshucks::Config::REQUIRED_CONNECTION_KEYS.each do |word|
+    it "should raise an exception if the backup name is the reserved config name '#{word}'" do
+      lambda { @config.backup(word) }.should raise_error(Awshucks::UnknownBackupError)
+    end
+  end
+  
+  Awshucks::Config::REQUIRED_BACKUP_CONFIG_KEYS.each do |key|
+    it "should raise an exception if the backup is missing a #{key}" do
+      lambda { @config.backup('invalid_backup') }.should raise_error(Awshucks::RequiredConfigError)
+    end
+  end
+    
+end
+
+describe Awshucks::Config, '#backups' do
+  before(:each) do
+    @config = Awshucks::Config.new(fixture_file('awshucks.yml'))
+  end
+  
+  it "should return the list of backup configurations in the config" do
+    @config.backups.should have_at_least(1).item
+  end
+  
+  it "should return backup configuration items" do
+    @config.backups.first.name.should == 'test_backup'
+  end
+  
+  Awshucks::Config::RESERVED_KEYS.each do |key|
+    it "should not include the reserved key #{key}" do
+      @config.backups.map {|b| b.name}.should_not include(key)
+    end
+  end
+    
+end
+
+describe Awshucks::Config do
+  it "has a help_message attribute" do
+    @config = Awshucks::Config.new(fixture_file('awshucks.yml'))
+    @config.help_message = 'help message'
+    @config.help_message.should == 'help message'
+  end
+end

data/spec/ext_spec.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+
+describe Object, '#returning' do
+  it "yields the provided argument, then returns it" do
+    yielded = nil
+    returning(:foo) do |obj|
+      yielded = obj
+    end.should == :foo
+    yielded.should == :foo
+  end
+end
+
+describe Object, '#in?' do
+  it "calls include? on the provided enumerable" do
+    collection = mock('collection')
+    item = mock('item')
+    collection.should_receive(:include?).with(item).and_return(true)
+    item.in?(collection).should be_true
+  end
+end
+
+describe File, '.md5sum' do
+  it "calls read on the provided filename and computes the MD5 hex digest" do
+    sum = Digest::MD5.hexdigest('lol')
+    File.should_receive('read').with('pretend/file').and_return('lol')
+    File.md5sum('pretend/file').should == sum
+  end
+end

data/spec/file_info_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+
+describe Awshucks::FileInfo do
+  
+  before(:each) do
+    @now = Time.now
+    @stat = mock('file stat instance')
+    @stat.stub!(:mtime).and_return(@now)
+    @stat.stub!(:size).and_return(12345)
+    @info = Awshucks::FileInfo.new('file', '/path/to/file', @stat)
+  end
+  
+  it "is initialized with a relative filename, a full path, and a File::Stat object" do
+    @info.should be_instance_of(Awshucks::FileInfo)
+  end
+  
+  it "has a filename" do
+    @info.filename.should == 'file'
+  end
+  
+  it "has a full filename path" do
+    @info.full_path.should == '/path/to/file'
+  end
+  
+  it "has an mtime in UTC" do
+    @info.mtime.should be_kind_of(Time)
+    @info.mtime.to_s.should == @now.gmtime.to_s
+  end
+  
+  it "has a lazily-evaluated md5sum" do
+    File.should_receive(:md5sum).with('/path/to/file').and_return('placeholder sum')
+    @info.md5sum.should == 'placeholder sum'
+  end
+  
+  it "returns an IO object when asked for the data" do
+    io = mock('pretend io')
+    File.should_receive(:open).and_return(io)
+    @info.data.should == io
+  end
+  
+  it "has a size (in bytes)" do
+    @info.size.should == 12345
+  end
+  
+end

data/spec/file_store_spec.rb

@@ -0,0 +1,352 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+
+describe Awshucks::FileStore do
+  
+  before(:each) do
+    @connection = mock('connection')
+    AWS::S3::Base.stub!(:establish_connection!)
+  end
+  
+  it "accepts a connection info hash, bucket name, and a backup prefix as parameters to initialize" do
+    Awshucks::FileStore.new(@connection, 'testbucket', 'testprefix').should be_instance_of(Awshucks::FileStore)
+  end
+  
+  it "establishes a connection to S3 using the config when initialized" do
+    AWS::S3::Base.should_receive(:establish_connection!).with(@connection)
+    fs = Awshucks::FileStore.new(@connection, 'testbucket', 'testprefix')
+  end
+  
+end
+
+describe Awshucks::FileStore, '#different_from? with a FileInfo object' do
+  
+  before(:each) do
+    
+    @bucket = mock('bucket')
+    @connection = mock('connection')
+    AWS::S3::Base.stub!(:establish_connection!)
+    AWS::S3::Bucket.stub!(:find).and_return(@bucket)
+    
+    # for the metadata cache:
+    @now = Time.now.gmtime
+    @sum = "7589253b2c5f744411e43be22eb45b71" # "lol what"
+    @sum2 = "0d705691a3dddd72b11f5e9b7d61a306" # "no wai"
+    @meta = mock('metadata')
+    @meta.stub!(:value).and_return("---\n{}") # empty hash
+    @bucket.should_receive(:[]).any_number_of_times.with('testprefix_metadata.yml').and_return(@meta)
+    
+    # for a pretend file stored on S3:
+    @file = mock('example stored s3 file')
+    @file.stub!(:key).and_return('testprefix/test/file')
+    
+    @info = mock(Awshucks::FileInfo)
+    @info.stub!(:filename).and_return('test/file')
+    # @info.stub!(:full_path).and_return('/path/to/file')
+    
+    @fs = Awshucks::FileStore.new(@connection, 'testbucket', 'testprefix')
+    
+  end
+
+  it "returns true if the file isn't stored in the file store already" do
+    @bucket.should_receive(:objects).with(:prefix => 'testprefix').and_return([])
+    @fs.different_from?(@info).should be_true
+  end
+  
+  it "returns false if the file's metadata mtime (in UTC!) matches" do
+    @bucket.should_receive(:objects).with(:prefix => 'testprefix').and_return([@file])
+    @file.stub!(:metadata).and_return('mtime' => @now.gmtime.to_s, 'md5sum' => @sum)
+    @info.should_receive(:mtime).at_least(1).times.and_return(@now)
+    @info.stub!(:md5sum).and_return(@sum)
+    @fs.different_from?(@info).should be_false
+  end
+
+  it "returns false if the file's mtime is different but the md5sum still matches" do
+    @bucket.should_receive(:objects).with(:prefix => 'testprefix').and_return([@file])
+    
+    @file.stub!(:metadata).and_return('mtime' => @now.gmtime.to_s, 'md5sum' => @sum)
+    @info.should_receive(:mtime).any_number_of_times.and_return(@now+5)
+    @info.should_receive(:md5sum).and_return(@sum)
+    @fs.different_from?(@info).should be_false
+  end
+  
+  it "updates the metadata cache with the new time if the file's mtime is different but md5sum is not" do
+    @meta.should_receive(:value).and_return(
+      {'test/file' => {'mtime' => @now, 'md5sum' => @sum}}.to_yaml
+    )
+    @info.should_receive(:mtime).twice.and_return(@now+5)
+    @info.should_receive(:md5sum).and_return(@sum)
+    @fs.different_from?(@info).should be_false
+    @fs.send(:metadata)['test/file']['mtime'].should == (@now+5).gmtime.to_s
+  end
+  
+  it "returns true if the file's mtime != the provided mtime and the md5sum doesn't match" do
+    @bucket.should_receive(:objects).with(:prefix => 'testprefix').and_return([@file])
+    
+    @file.stub!(:metadata).and_return('mtime' => @now.gmtime.to_s, 'md5sum' => @sum)
+    @info.should_receive(:mtime).and_return(@now+5)
+    @info.should_receive(:md5sum).and_return(@sum2)
+    
+    @fs.different_from?(@info).should be_true
+  end
+  
+  it "preferentially uses the metadata cache to retrieve file information" do
+    @meta.should_receive(:value).and_return(
+      {'test/file' => {'mtime' => @now, 'md5sum' => @sum}}.to_yaml
+    )
+    
+    @info.should_receive(:mtime).and_return(@now+5)
+    @info.should_receive(:md5sum).and_return(@sum2)
+    
+    @fs.different_from?(@info).should be_true
+  end
+  
+  it "falls back to the stored file on s3 for metadata if it's not in the cache" do
+    # the metadata cache is empty...
+    @file.should_receive(:metadata).at_least(1).times.and_return('mtime' => @now.gmtime.to_s, 'md5sum' => @sum)
+    @bucket.should_receive(:objects).with(:prefix => 'testprefix').and_return([@file])
+    
+    @info.should_receive(:mtime).and_return(@now+5)
+    @info.should_receive(:md5sum).and_return(@sum2)
+
+    @fs.different_from?(@info).should be_true
+  end
+    
+end
+
+describe Awshucks::FileStore, '#each_file' do
+  
+  before(:each) do
+    AWS::S3::Base.stub!(:establish_connection!)
+    @bucket = mock('bucket')
+    @bucket.stub!(:name).and_return('testbucket')
+    @bucket.stub!(:[])
+    
+    AWS::S3::Bucket.stub!(:find).and_return(@bucket)
+    
+    @fs = Awshucks::FileStore.new(nil, 'testbucket', 'testprefix')    
+  end
+  
+  it "yields each filename stored in the bucket matching the configured prefix, with the prefix removed" do
+    @fileone = mock('file one')
+    @fileone.stub!(:key).and_return('testprefix/some/file')
+    @filetwo = mock('file two')
+    @filetwo.stub!(:key).and_return('testprefix/another')
+    @bucket.should_receive(:objects).with(:prefix => 'testprefix').and_return([@fileone, @filetwo])
+    
+    yielded = []
+    @fs.each_file { |filename| yielded << filename }
+    yielded.should == %w(some/file another)
+  end
+  
+  it "does not yield the metadata file" do
+    @meta = mock('metadata')
+    @meta.stub!(:key).and_return('testprefix_metadata.yml')
+    @fileone = mock('file one')
+    @fileone.stub!(:key).and_return('testprefix/some/file')
+    @bucket.should_receive(:objects).with(:prefix => 'testprefix').and_return([@fileone, @meta])
+    
+    yielded = []
+    @fs.each_file { |filename| yielded << filename }
+    yielded.should == %w(some/file)
+  end
+  
+end
+
+describe Awshucks::FileStore, '#store' do
+  
+  before(:each) do
+    AWS::S3::Base.stub!(:establish_connection!)
+    
+    @bucket = mock('bucket')
+    @bucket.stub!(:name).and_return('testbucket')
+    @bucket.stub!(:[])
+    
+    AWS::S3::Bucket.stub!(:find).and_return(@bucket)
+    
+    @response = mock('s3 response object')
+    @response.stub!(:success?).and_return true
+    
+    @gmtime = Time.now.gmtime
+    @sum = 'pretend md5 sum'
+    
+    @info = mock('fileinfo')
+    @info.stub!(:filename).and_return('test/file')
+    @info.stub!(:mtime).and_return(@gmtime)
+    @info.stub!(:data).and_return('data')
+    @info.stub!(:md5sum).and_return(@sum)
+    
+    ::AWS::S3::S3Object.should_receive(:store).with('testprefix/test/file', 'data', 'testbucket', {
+      'x-amz-meta-mtime' => @gmtime.to_s, 'x-amz-meta-md5sum' => @sum
+    }).and_return(@response)
+    
+    @fs = Awshucks::FileStore.new(nil, 'testbucket', 'testprefix')    
+  end
+  
+  it "stores the provided file data, including the modified time as metadata" do
+    @fs.store(@info)
+  end
+  
+  it "includes the stored file in the metadata cache" do
+    @fs.store(@info)
+    @fs.send(:metadata).should == {'test/file' => {'mtime' => @gmtime.to_s, 'md5sum' => @sum}}
+  end
+  
+end
+
+describe Awshucks::FileStore, '#restore' do
+  
+  before(:each) do
+    AWS::S3::Base.stub!(:establish_connection!)
+    @bucket = mock('bucket')
+    @bucket.stub!(:name).and_return('testbucket')
+    @bucket.stub!(:[])
+    
+    @sum = "imaginary md5 sum"
+    
+    @meta = mock('metadata object')
+    @meta.stub!(:key).and_return('testprefix_metadata.yml')
+    @meta.stub!(:value).and_return(
+      {'some/file' => {'mtime' => Time.now.gmtime.to_s, 'md5sum' => @sum}}.to_yaml
+    )
+
+    @bucket.should_receive(:[]).with('testprefix_metadata.yml').any_number_of_times.and_return(@meta)
+    
+    AWS::S3::Bucket.stub!(:find).and_return(@bucket)
+    
+    @file = mock('pretend s3 file')
+    @file.stub!(:key).and_return('testprefix/some/file')
+    @file.stub!(:value).and_yield('value')
+    
+    # @bucket.stub!(:objects).and_return([@file, @meta])
+    
+    @filehandle = mock('filehandle')
+
+    FileUtils.stub!(:mkdir_p)
+    File.stub!(:md5sum).and_return(@sum)
+    
+    @fs = Awshucks::FileStore.new(nil, 'testbucket', 'testprefix')
+    @old_stderr, $stderr = $stderr, StringIO.new
+  end
+  
+  after(:each) do
+    $stderr = @old_stderr
+  end
+    
+  it "raises an exception if the specified file doesn't exist in the bucket" do
+    @bucket.should_receive(:[]).with('testprefix/some/file').and_return(nil)
+    lambda {@fs.restore('some/file', 'foo/bar/some/file') }.should raise_error(Awshucks::UnknownFileError)
+  end
+  
+  it "restores the specified file to the specified location" do
+    @bucket.should_receive(:[]).with('testprefix/some/file').and_return(@file)
+    File.should_receive(:open).with('/absolute/location/some/file', 'w').and_yield(@filehandle)
+    @filehandle.should_receive(:write).with('value')
+    @fs.restore('some/file', '/absolute/location/some/file')
+  end
+  
+  it "creates the directory tree necessary to restore the file" do
+    @bucket.should_receive(:[]).with('testprefix/some/file').and_return(@file)
+    File.stub!(:open).and_yield(@filehandle)
+    @filehandle.stub!(:write)
+    
+    FileUtils.should_receive(:mkdir_p).with('/absolute/location/some')
+    @fs.restore('some/file', '/absolute/location/some/file')
+  end
+  
+  it "prints a warning if the md5sum of the written file doesn't match the stored metadata" do
+    @bucket.should_receive(:[]).with('testprefix/some/file').and_return(@file)
+    File.stub!(:open).and_yield(@filehandle)
+    @filehandle.stub!(:write)
+    
+    File.should_receive(:md5sum).with('/absolute/location/some/file').and_return('different sum')
+    @fs.restore('some/file', '/absolute/location/some/file')
+    
+    $stderr.string.should =~ /warning.*md5/i
+  end
+  
+end
+
+describe Awshucks::FileStore, '#save_cache' do
+  
+  before(:each) do
+    @bucket = mock('bucket')
+    @bucket.stub!(:name).and_return('testbucket')
+    @connection = mock('connection')
+    AWS::S3::Base.should_receive(:establish_connection!).with(@connection)
+    @fs = Awshucks::FileStore.new(@connection, 'testbucket', 'testprefix')
+    @fs.stub!(:bucket).and_return(@bucket)
+    @meta = mock('metadata')
+    @meta.stub!(:value).and_return("---\nfoo: bar")
+    @meta.stub!(:to_yaml).and_return("--- \nfoo: bar\n")
+  end
+  
+  it "stores the metadata file on S3" do
+    @bucket.stub!(:[]).and_return(@meta)
+    AWS::S3::S3Object.should_receive(:store).with('testprefix_metadata.yml', "--- \nfoo: bar\n", 'testbucket')
+    @fs.save_cache
+  end
+end
+
+describe Awshucks::FileStore, '#reset_cache' do
+  
+  before(:each) do
+    AWS::S3::Base.stub!(:establish_connection!)
+    @bucket = mock('bucket')
+    @bucket.stub!(:name).and_return('testbucket')
+    @bucket.stub!(:[])
+    
+    AWS::S3::Bucket.stub!(:find).and_return(@bucket)
+    
+    @fs = Awshucks::FileStore.new(nil, 'testbucket', 'testprefix')    
+    
+    @old_stdout, $stdout = $stdout, StringIO.new
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+  end
+  
+  it "deletes the metadata cache file from the S3 service" do
+    AWS::S3::S3Object.should_receive(:delete).with('testprefix_metadata.yml', 'testbucket')
+    @fs.reset_cache
+  end
+  
+end
+
+describe Awshucks::FileStore, '#bucket (private method)' do
+  
+  before(:each) do
+    @connection = mock('connection')
+    AWS::S3::Base.should_receive(:establish_connection!).with(@connection)
+    @fs = Awshucks::FileStore.new(@connection, 'testbucket', 'testprefix')
+    @old_stdout, $stdout = $stdout, StringIO.new
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+  end
+  
+  it "returns the S3 bucket matching the configured bucket name" do
+    bucket = mock('bucket')
+    AWS::S3::Bucket.should_receive(:find).with('testbucket').and_return(bucket)
+    @fs.send(:bucket).should == bucket
+  end
+  
+  it "creates the bucket and returns it if the bucket doesn't already exist" do
+    bucket = mock('bucket')
+        
+    raised = false
+    AWS::S3::Bucket.should_receive(:find).twice.with('testbucket').and_return do
+      if raised
+        bucket
+      else
+        raised = true
+        raise AWS::S3::ResponseError.new("The specified bucket does not exist", nil)
+      end
+    end
+    AWS::S3::Bucket.should_receive(:create).with('testbucket').and_return(true)
+    
+    @fs.send(:bucket).should == bucket    
+  end
+  
+end