monsoon 0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in monsoon.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,4 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/monsoon/(.+)\.rb}) { |m| "spec/monsoon/#{m[1]}_spec.rb" }
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Brandon Hilkert
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+Monsoon Gem
+=======================
+
+Monsoon is a MongoDB backup tool that allows you to take backups and store them in Amazon S3.
+
+
+Usage
+-----
+
+To install:
+
+    gem install monsoon
+
+To Configure:
+
+    Monsoon.configure do |config|
+      config.bucket = "mongo_backups"
+      config.key = "my_super_secret_aws_key"
+      config.secret = "my_super_secret_aws_secret"
+      config.backup_directory = "tmp"
+      config.mongo_uri = "mongodb://user:password@test.mongohq.com:10036/add_development"
+    end
+
+To use:
+
+    client = Monsoon::Client.new
+    client.run
+
+
+Requirements
+----
+
+`mongodump` must be installed on the system and available from anywhere on in the console.
+
+The gem also utilizes `tar` to compress the back so this, too, must be accessible form the command line.
+  
+Released under the [MIT license](http://www.opensource.org/licenses/mit-license.php).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+task :default => :spec

data/lib/monsoon/backup.rb

@@ -0,0 +1,79 @@
+require 'uri'
+
+module Monsoon
+  class Backup
+
+    attr_reader :backup_directory
+
+    def initialize(uri, backup_directory = "tmp")
+      @uri = uri
+      @backup_directory = backup_directory
+    end
+
+    # Run the Monsoon Backup process.
+    #
+    # Examples
+    #
+    #   Monsoon::Backup("mongodb://@test.mongohq.com:10036/app_development").run
+    #   # => #<Monsoon::Backup>
+    #
+    # Returns an instance of the Monsoon::Backup class
+    def run
+      Kernel.system "#{mongo_dump_command}"
+      self
+    end       
+
+    # Creates the config hash for the connection string
+    #
+    # Examples
+    #
+    #   Monsoon::Backup("mongodb://test.mongohq.com:10036/app_development").config
+    #   # => {"host" => "test.mongohq.com", 
+    #         "post" => 10036, 
+    #         "database" => "app_development",
+    #         "username" => "testuser",
+    #         "password" => "pass1"}
+    #
+    # Returns an instance of the Monsoon::Backup class
+    def config
+      return {} unless @uri
+
+      uri = URI.parse(@uri)
+      raise "must be a mongo DB" unless uri.scheme == 'mongodb'
+      {
+        "host"     => uri.host,
+        "port"     => uri.port,
+        "database" => uri.path.gsub(/^\//, ''),
+        "username" => uri.user,
+        "password" => uri.password
+      }
+    end    
+
+    # Helper method for database name.
+    #
+    # Examples
+    #
+    #   Monsoon::Backup("mongodb://test.mongohq.com:10036/app_development").database
+    #   # => "app_development"
+    #
+    # Returns a String of the database name.
+    def database
+      config["database"]
+    end
+
+    # Helper to form the mongodump command.
+    #
+    # Examples
+    #
+    #   Monsoon::Backup("mongodb://test.mongohq.com:10036/app_development").mongo_dump_command
+    #   # => "mongodump -h test.mongohq.com:10036 -d app_development -o tmp"
+    #
+    # Returns the command as a String.
+    def mongo_dump_command
+      cmd = ""
+      cmd = "mongodump -h #{config['host']}:#{config['port']} -d #{config['database']} -o #{@backup_directory} "
+      cmd += "--username #{config['username']} --password #{config['password']}" unless config["username"].nil? and config["password"].nil?
+      cmd
+    end
+  end
+end

data/lib/monsoon/client.rb

@@ -0,0 +1,77 @@
+module Monsoon
+  class Client
+
+    def initialize(bucket = Monsoon.bucket, key = Monsoon.key, secret = Monsoon.secret, backup_directory = Monsoon.backup_directory, mongo_uri = Monsoon.mongo_uri)
+      @bucket           = bucket
+      @key              = key
+      @secret           = secret
+      @backup_directory = backup_directory
+      @mongo_uri        = mongo_uri
+    end
+
+    # Run the Monsoon process to backup, save, and clean the work.
+    #
+    # Examples
+    #
+    #   Monsoon::Client.new.run
+    #   # => True
+    #
+    # Returns True
+    def run
+      # Backup the MongoDB database to filesystem
+      b = backup.run
+      
+      # Compress the contents of the backup
+      c = compress(b).run
+      
+      # Sent to AWS
+      store(c.filename).save
+
+      # Remove the compressed file from the filesystem
+      c.clean
+
+      true
+    end
+
+    # Creates an instance of the Monsoon::Backup class
+    #
+    # Examples
+    #
+    #   Monsoon::Client.new.backup
+    #   # => #<Monsoon::Backup>
+    #
+    # Returns an instance of the Monsoon::Client object
+    def backup
+      Backup.new(@mongo_uri, @backup_directory)
+    end
+
+    # Creates an instnace of the Monsoon::Compress class
+    #
+    # backup  - The Monsoon::Backup instance the preceeded.
+    #
+    # Examples
+    #
+    #   Monsoon::Client.new.compress(#<Monsoon::Backup>)
+    #   # => #<Monsoon::Compress>
+    #
+    # Returns an instance of the Monsoon::Compress object
+    def compress(backup)
+      Compress.new(backup)
+    end
+      
+    # Creates an instance of the Monsoon::Store class
+    #
+    # filename  - The String filename of the compressed backup to push to S3.
+    #
+    # Examples
+    #
+    #   Monsoon::Client.new.store("test.tar.gz")
+    #   # => #<Monsoon::Store>
+    #
+    # Returns an instance of the Monsoon::Store object
+    def store(filename)
+      Store.new(filename, @bucket, @key, @secret)
+    end
+
+  end
+end

data/lib/monsoon/compress.rb

@@ -0,0 +1,60 @@
+require 'fileutils'
+
+module Monsoon
+  class Compress
+
+    def initialize(backup)
+      @backup = backup
+    end
+
+    # Run the Monsoon Compress process.
+    #
+    # Examples
+    #
+    #   Monsoon::Compress(#<Monsoon::Backup>).run
+    #   # => #<Monsoon::Compress>
+    #
+    # Returns an instance of the Monsoon::Compress class
+    def run
+      Kernel.system "#{compress_command}"
+      self
+    end
+
+    # Helper to form the tar compress command.
+    #
+    # Examples
+    #
+    #   Monsoon::Compress(#<Monsoon::Backup>).compress_command
+    #   # => "tar -czf app_development_1234.tar.gz tmp"
+    #
+    # Returns the command as a String.
+    def compress_command
+      "tar -czf  #{filename} #{@backup.backup_directory}"
+    end
+
+    # Helper to form the tar compress command.
+    #
+    # Examples
+    #
+    #   Monsoon::Compress(#<Monsoon::Backup>).filename
+    #   # => "app_development_1234.tar.gz"
+    #
+    # Returns the filename as a String.
+    def filename
+      @filename ||= "#{@backup.database}_#{Time.now.utc.to_i.to_s}.tar.gz"
+    end
+
+    # Helper to delete the backup file once finished.
+    #
+    # Examples
+    #
+    #   Monsoon::Compress(#<Monsoon::Backup>).clean
+    #   # => "app_development_1234.tar.gz"
+    #
+    # Returns results of the command.
+    def clean
+      FileUtils.rm filename, force: true
+    end
+
+  end
+end

data/lib/monsoon/store.rb

@@ -0,0 +1,55 @@
+begin
+  require "aws/s3"
+rescue LoadError
+  raise "You don't have the 'aws' gem installed."
+end
+
+module Monsoon
+  class Store
+
+    def initialize(filename, bucket, key, secret)
+      @filename, @bucket, @key, @secret  = filename, bucket, key, secret
+    end
+
+    # Runs the Monsoon Store save process.
+    #
+    # Examples
+    #
+    #   Monsoon::Store("backup.tar.gz", "backups_bucket", "super_secret_key", "super_secret_secret").save
+    #   # => #<AWS::S3::S3Object>
+    #
+    # Returns an instance of the AWS::S3::S3Object class
+    def save
+      connect
+      AWS::S3::S3Object.store(@filename, read_file_contents, @bucket)
+    end
+
+    # Parses the contents of the compressed backup.
+    #
+    # Examples
+    #
+    #   Monsoon::Store("backup.tar.gz", "backups_bucket", "super_secret_key", "super_secret_secret").read_file_contents
+    #   # => #<AWS::S3::S3Object>
+    #
+    # Returns contents of the binary file.
+    def read_file_contents
+      file = File.open(@filename, "rb")
+      file.read
+    end
+
+    # Connects to AWS.
+    #
+    # Examples
+    #
+    #   Monsoon::Store("backup.tar.gz", "backups_bucket", "super_secret_key", "super_secret_secret").connect
+    #   # => #<AWS::S3::Connection>
+    #
+    # Returns an instance of the AWS::S3::Connection class.
+    def connect
+      AWS::S3::Base.establish_connection!(
+        :access_key_id     => @key, 
+        :secret_access_key => @secret
+      )
+    end
+  end
+end

data/lib/monsoon/version.rb

@@ -0,0 +1,3 @@
+module Monsoon
+  VERSION = "0.1"
+end

data/lib/monsoon.rb

@@ -0,0 +1,39 @@
+module Monsoon
+
+  class << self
+    attr_accessor :bucket, :key, :secret, :backup_directory, :mongo_uri
+
+    # config/initializers/monsoon.rb (for instance)
+    #
+    # Monsoon.configure do |config|
+    #   config.bucket = 'backups'
+    #   config.key = 'consumer_key'
+    #   config.secret = 'consumer_secret'
+    #   config.backup_directory = 'data'
+    #   config.mongo_uri = 'mongodb://testuser:pass1@test.mongohq.com:10036/app_development'
+    # end
+    #
+    def configure
+      yield self
+      true
+    end
+
+    # Run the Monsoon process to backup, save, and clean the work.
+    #
+    # Examples
+    #
+    #   Monsoon.perform
+    #   # => True
+    #
+    # Returns True
+    def perform
+      Monsoon::Client.new.run
+    end
+  end
+
+  autoload :Backup,     "monsoon/backup"
+  autoload :Client,     "monsoon/client"
+  autoload :Compress,   "monsoon/compress"
+  autoload :Store,      "monsoon/store"
+  autoload :Version,    "monsoon/version"
+end

data/monsoon.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "monsoon/version"
+
+Gem::Specification.new do |s|
+  s.name        = "monsoon"
+  s.version     = Monsoon::VERSION
+  s.authors     = ["Brandon Hilkert"]
+  s.email       = ["brandonhilkert@gmail.com"]
+  s.homepage    = "https://github.com/brandonhilkert/egg_carton"
+  s.summary     = %q{Monsoon MongoDB Backup Utility}
+  s.description = %q{Monsoon is a MongoDB backup tool that allows you to take backups and store them in Amazon S3.}
+
+  s.rubyforge_project = "monsoon"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec", "~> 2.8"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "rake"
+
+  s.add_dependency "aws-s3"
+end

data/spec/monsoon/backup_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+module Monsoon
+
+  describe Backup do
+    let(:uri) { "mongodb://testuser:pass1@test.mongohq.com:10036/app_development" }
+    let(:directory) { "tmp" }
+
+    describe "initalization" do
+      let(:backup) { Backup.new(uri) }
+
+      it "should set the @uri instance variable" do
+        backup.instance_variable_get(:@uri).should == uri
+      end
+
+      it "should set the @directory instance variable to default directory if none is provided" do
+        backup.instance_variable_get(:@backup_directory).should == "tmp"
+      end
+      
+      it "should set the @directory instance variable to specified directory" do
+        backup = Backup.new(uri, "tmp/data")
+        backup.instance_variable_get(:@backup_directory).should == "tmp/data"
+      end
+
+      it "should be able to read backup_directory instance variable" do
+        backup.backup_directory.should == "tmp"
+      end
+    end
+
+    describe "#run" do
+      let(:backup) { Backup.new(uri) }
+
+      before(:each) do
+        backup.stub(:mongo_dump_command).and_return("mongodump -h test -p 10000")
+        Kernel.stub(:system).and_return(nil)
+      end
+
+      it "should run call on system" do
+        Kernel.should_receive(:system).with("mongodump -h test -p 10000")
+        backup.run
+      end
+
+      it "should call mongo_dump method" do
+        backup.should_receive(:mongo_dump_command)
+        backup.run
+      end
+
+      it "should return backup instance" do
+        backup.run.should == backup
+      end
+    end
+
+    describe "#config" do
+      it "should raise error if uri is not a mongodb connection string" do
+        bad_uri = "http://user:pass1@test.mongohq.com:10036/app_development"
+
+        b = Backup.new(bad_uri)
+        expect { raise b.config }.to raise_error
+      end
+
+      describe "with valid URI" do
+        subject{ Backup.new(uri).config }
+
+        it "should return 'test.mongohq.com' as the host" do
+          subject["host"].should == "test.mongohq.com"
+        end
+        
+        it "should return 10036 as the port" do
+          subject["port"].should == 10036
+        end
+        
+        it "should return 'app_development' as the database" do
+          subject["database"].should == "app_development"
+        end
+        
+        it "should return 'testuser' as the username" do
+          subject["username"].should == "testuser"
+        end
+        
+        it "should return 'pass1' as the password" do
+          subject["password"].should == "pass1"
+        end
+      end
+    end
+
+    describe "#database" do
+      subject{ Backup.new(uri).database }
+
+      it "should return 'app_development' for database" do
+        subject.should == "app_development"
+      end
+    end
+
+    describe "#mongo_dump_command" do
+      subject{ Backup.new(uri).mongo_dump_command }
+
+      it "should include mongo dump command" do
+        subject.should include("mongodump")
+      end
+
+      it "should include switch for host including port" do
+        subject.should include("-h test.mongohq.com:10036")
+      end
+
+      it "should include switch for database" do
+        subject.should include("-d app_development")
+      end
+
+      it "should include switch for username" do
+        subject.should include("--username testuser")
+      end
+
+      it "should include switch for password" do
+        subject.should include("--password pass1")
+      end
+
+      it "should include switch for output directory" do
+        subject.should include("-o tmp")
+      end
+
+      it "should change output directory if intialized with it" do
+        Backup.new(uri, "tmp/data").mongo_dump_command.should include("-o tmp/data")
+
+      end
+
+      describe "when user and password is not included" do
+        let(:backup) { Backup.new("mongodb://test.mongohq.com:10036/app_development").mongo_dump_command }
+
+        it "should not include username switch" do
+          backup.should_not include("--username")
+        end
+
+        it "should not include password switch" do
+          backup.should_not include("--password")
+        end
+      end
+
+
+    end
+
+  end
+
+end

data/spec/monsoon/client_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+module Monsoon
+
+  describe Client do
+    let(:bucket) { "bucket" }
+    let(:key) { "key" }
+    let(:secret) { "secret" }
+    let(:backup_directory) { "tmp" }
+    let(:mongo_uri) { "mongodb://testuser:pass1@test.mongohq.com:10036/app_development" }
+    let(:client) { Monsoon::Client.new(bucket, key, secret, backup_directory, mongo_uri) }
+
+    describe "initalization" do
+      it "should set the @bucket instance variable" do
+        client.instance_variable_get(:@bucket).should == bucket
+      end
+
+      it "should set the @key instance variable" do
+        client.instance_variable_get(:@key).should == key
+      end
+
+      it "should set the @secret instance variable" do
+        client.instance_variable_get(:@secret).should == secret
+      end
+
+      it "should set the @backup_directory instance variable" do
+        client.instance_variable_get(:@backup_directory).should == backup_directory 
+      end
+
+      it "should set the @mongo_uri instance variable" do
+        client.instance_variable_get(:@mongo_uri).should == mongo_uri
+      end
+
+      describe "config variables" do
+        it "should set instance variable bucket" do
+          Monsoon.bucket = "bucket"
+          c = Monsoon::Client.new
+          c.instance_variable_get(:@bucket).should == "bucket"
+        end
+
+        it "should set instance variable key" do
+          Monsoon.key = "key"
+          c = Monsoon::Client.new
+          c.instance_variable_get(:@key).should == "key"
+        end
+
+        it "should set instance variable secret" do
+          Monsoon.secret = "secret"
+          c = Monsoon::Client.new
+          c.instance_variable_get(:@secret).should == "secret"
+        end
+
+        it "should set instance variable backup_directory" do
+          Monsoon.backup_directory = "tmp/data"
+          c = Monsoon::Client.new
+          c.instance_variable_get(:@backup_directory).should == "tmp/data"
+        end
+
+        it "should set instance variable mongo_uri" do
+          Monsoon.mongo_uri = "mongo://localhost"
+          c = Monsoon::Client.new
+          c.instance_variable_get(:@mongo_uri).should == "mongo://localhost"
+        end
+      end
+
+    end
+
+    describe "#run" do
+      let(:backup) { Backup.new(mongo_uri, backup_directory) }
+      let(:compress) { Compress.new(backup) }
+      let(:store) { Store.new(compress, bucket, key, secret) }
+
+      before(:each) do
+        Backup.any_instance.stub(:run).and_return(backup)
+        Compress.any_instance.stub(:run).and_return(compress)
+        Store.any_instance.stub(:save).and_return(store)
+      end
+
+      it "should run the backup process" do
+        Backup.any_instance.should_receive(:run)
+        client.run
+      end
+
+      it "should run the compress process" do
+        Compress.any_instance.should_receive(:run)
+        client.run
+      end
+
+      it "should run the store process" do
+        Store.any_instance.should_receive(:save)
+        client.run
+      end
+
+      it "should remove the compressed file" do
+        compress.should_receive(:clean)
+        client.run
+      end
+    end
+
+    describe "#backup" do
+      it "should initalize a new Backup object" do
+        Backup.should_receive(:new).with(mongo_uri, backup_directory)
+        client.backup
+      end
+    end
+
+    describe "#compress" do
+      let(:backup) { Backup.new(mongo_uri, backup_directory) }
+
+      it "should initalize a new Compress object" do
+        Compress.should_receive(:new).with(backup)
+        client.compress(backup)
+      end
+    end
+
+    describe "#store" do
+      let(:backup) { Backup.new(mongo_uri, backup_directory) }
+      let(:compress) { Compress.new(backup) }
+
+      it "should initalize a new Compress object" do
+        Compress.should_receive(:new).with(compress, bucket, key, secret)
+        client.store(compress)
+      end
+    end
+
+  end
+
+end

data/spec/monsoon/compress_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module Monsoon
+
+  describe Compress do
+    let(:backup) { double("backup", backup_directory: "tmp", database: "app_development") }
+    let(:compress) { Compress.new(backup) }
+
+    describe "initalization" do
+      it "should set the @directory instance variable" do
+        compress.instance_variable_get(:@backup).should == backup
+      end
+    end
+
+    describe "#run" do
+      before(:each) do
+        compress.stub(:compress_command).and_return("tar -czf")
+        Kernel.stub(:system).and_return(nil)
+      end
+
+      it "should run call on system" do
+        Kernel.should_receive(:system).with("tar -czf")
+        compress.run
+      end
+
+      it "should call compress method" do
+        compress.should_receive(:compress_command)
+        compress.run
+      end
+
+      it "should return compress instance" do
+        compress.run.should == compress
+      end
+    end
+
+    describe "#compress_command" do
+      it "should include the tar command" do
+        compress.compress_command.should include("tar -czf")
+      end
+
+      it "should include filename with timestamp and tar.gz extension" do
+        compress.stub(:filename).and_return("app_development.1234.tar.gz")
+        compress.compress_command.should include("app_development.1234.tar.gz")
+      end
+    end
+
+    describe "#filename" do
+      it "should return the correct filename with timestamp" do
+        Time.stub_chain(:now, :utc, :to_i, :to_s).and_return("1234")
+        compress.filename.should == "app_development_1234.tar.gz"
+      end
+
+      it "should return original filename if subsequently requseted" do
+        Time.stub_chain(:now, :utc, :to_i, :to_s).and_return("1234")
+        filename = compress.filename
+        Time.stub_chain(:now, :utc, :to_i, :to_s).and_return("0000")
+        compress.filename.should == filename
+      end
+    end
+
+    describe "#clean" do
+      let(:filename) { compress.filename }
+
+      it "should trigger the rm command" do
+        FileUtils.should_receive(:rm).with(filename, force: true)
+        compress.clean
+      end
+
+      it "should delete a file" do
+        File
+      end
+    end
+
+  end
+
+end

data/spec/monsoon/store_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module Monsoon
+
+  describe Store do
+    let(:store) { Store.new("app_development.tar.gz", "backups", "key", "secret") }
+
+    describe "initalization" do
+      it "should set the @filename instance variable" do
+        store.instance_variable_get(:@filename).should == "app_development.tar.gz"
+      end
+
+      it "should set the @key instance variable" do
+        store.instance_variable_get(:@key).should == "key"
+      end
+
+      it "should set the @secret instance variable" do
+        store.instance_variable_get(:@secret).should == "secret"
+      end
+
+      it "should set the @bucket instance variable" do
+        store.instance_variable_get(:@bucket).should == "backups"
+      end
+
+    end
+
+    describe "#save" do
+      before(:each) do
+        AWS::S3::S3Object.stub(:store).and_return(AWS::S3::S3Object)
+        store.stub(:read_file_contents).and_return("test")
+      end
+
+      it "should connect to AWS" do
+        store.should_receive(:connect)
+        store.save
+      end
+
+      it "should execute store method on fog S3Object" do
+        AWS::S3::S3Object.should_receive(:store).with("app_development.tar.gz", "test", "backups")
+        store.save
+      end
+
+      it "should call the read_file_contents method" do
+        store.should_receive(:read_file_contents)
+        store.save
+      end
+    end
+
+    describe "#read_file_contents" do
+      before(:each) do
+        File.stub(:open).with("app_development.tar.gz", "rb").and_return("test")
+        String.any_instance.stub(:read).and_return("test")
+      end
+
+      it "should open the File" do
+        File.should_receive(:open).with("app_development.tar.gz", "rb")
+        store.read_file_contents
+      end
+
+      it "should execute the read operation on the file object" do
+        String.any_instance.should_receive(:read)
+        store.read_file_contents
+      end
+    end
+
+    describe "#connect" do
+      subject{ store.connection }
+
+      it "should connect to AWS" do
+        AWS::S3::Base.should_receive(:establish_connection!).with(:access_key_id => "key", :secret_access_key => "secret")
+        store.connect
+      end
+    end
+
+  end
+
+end

data/spec/monsoon_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Monsoon do
+  before(:each) do
+    Monsoon.bucket = nil
+    Monsoon.key = nil
+    Monsoon.secret = nil
+    Monsoon.backup_directory = nil
+    Monsoon.mongo_uri = nil
+  end
+
+  it "should be able to set AWS properties" do
+    Monsoon.bucket = "backups"
+    Monsoon.key = "key"
+    Monsoon.secret = "secret"
+
+    Monsoon.bucket.should == "backups"
+    Monsoon.key.should == "key"
+    Monsoon.secret.should == "secret"
+  end
+
+  it "should be able to set options through configure block" do
+    Monsoon.configure do |config|
+      config.bucket             = "backups"
+      config.key                = "key"
+      config.secret             = "secret"
+      config.backup_directory   = "tmp/data"
+      config.mongo_uri          = "mongodb://testuser:pass1@test.mongohq.com:10036/app_development"
+    end
+
+    Monsoon.bucket.should == "backups"
+    Monsoon.key.should == "key"
+    Monsoon.secret.should == "secret"
+    Monsoon.backup_directory.should == "tmp/data"
+    Monsoon.mongo_uri.should == "mongodb://testuser:pass1@test.mongohq.com:10036/app_development"
+  end
+
+  describe ".perform" do
+    before(:each) do
+      Monsoon::Client.any_instance.stub(:run).and_return(true)
+    end
+
+    it "should excute the run method on a client instance" do
+      Monsoon::Client.any_instance.should_receive(:run)
+      Monsoon.perform
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'monsoon'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: monsoon
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Brandon Hilkert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70222012651180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: *70222012651180
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70222012650760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70222012650760
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70222012650300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70222012650300
+- !ruby/object:Gem::Dependency
+  name: aws-s3
+  requirement: &70222024478080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70222024478080
+description: Monsoon is a MongoDB backup tool that allows you to take backups and
+  store them in Amazon S3.
+email:
+- brandonhilkert@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/monsoon.rb
+- lib/monsoon/backup.rb
+- lib/monsoon/client.rb
+- lib/monsoon/compress.rb
+- lib/monsoon/store.rb
+- lib/monsoon/version.rb
+- monsoon.gemspec
+- spec/monsoon/backup_spec.rb
+- spec/monsoon/client_spec.rb
+- spec/monsoon/compress_spec.rb
+- spec/monsoon/store_spec.rb
+- spec/monsoon_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/brandonhilkert/egg_carton
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: monsoon
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Monsoon MongoDB Backup Utility
+test_files:
+- spec/monsoon/backup_spec.rb
+- spec/monsoon/client_spec.rb
+- spec/monsoon/compress_spec.rb
+- spec/monsoon/store_spec.rb
+- spec/monsoon_spec.rb
+- spec/spec_helper.rb