hsume2-cap-taffy 1.0.0 → 1.0.1

data/History.txt

@@ -1,3 +1,7 @@
+== 1.0.1 / 2009-09-14
+* 1 minor enhancement
+  * Added authorizing SSH public keys on remote server(s).
+
 == 1.0.0 / 2009-09-14
 
 * 1 major enhancement

data/README.md

@@ -7,6 +7,7 @@ Features
 ------------------------------------------------
 
 * Adds database transfer recipes (via [`Taps`]("http://github.com/ricardochimal/taps"))
+* Authorize SSH access
 * Manage `database.yml` (Soon.)
 
 [`Taps`]("http://github.com/ricardochimal/taps") is great, but having to SSH into my deployment to run the `Taps` server, as well as 
@@ -20,11 +21,9 @@ Installation
 
     gem install cap-taffy
 
-Usage
+Database Transfer
 ------------------------------------------------
 
-### `Taffy`: Database Transfer
-
 > _Dependency:_ The [`Taps`]("http://github.com/ricardochimal/taps") gem is required on any server(s) you'll be transferring databases to (`:app` role) including your development machine (where you'll be running `cap` tasks from). Run:
 
 >     gem install taps
@@ -33,6 +32,8 @@ Usage
 
 >     gem install heroku
 
+### Usage
+
 To start, add the following to your `Capfile`
 
     require 'cap-taffy/db'
@@ -58,7 +59,22 @@ Then you can use:
 > >     ssh -N -L4321:127.0.0.1:4321 henry@load-test
 > >     cap db:push -s taps_port=4321 -s local=true
 
-### Managing `database.yml`
+SSH Access
+------------------------------------------------
+
+#### Usage
+
+Add the following to your `Capfile`
+
+    require 'cap-taffy/ssh'
+
+Using a public key generated from `ssh-keygen` (e.g. `ssh-keygen -t rsa`), to authorize access:
+
+    cap ssh:authorize       # authorizes local public key for SSH access to remote server(s)
+
+
+Managing `database.yml`
+------------------------------------------------
 
 > Much needed and coming soon.
 

data/Rakefile

@@ -26,6 +26,7 @@ PROJ.version = CapTaffy::VERSION
 PROJ.rubyforge.name = 'cap-taffy'
 PROJ.readme_file = "README.md"
 PROJ.gem.dependencies = ['heroku', 'taps', 'capistrano']
+PROJ.gem.development_dependencies << ["mocha"]
 PROJ.description = "Capistrano recipes for deploying databases and other common tasks."
 PROJ.summary = "Capistrano recipes for deploying databases (managing database.yml, importing/exporting/transfering databases, etc.)"
 PROJ.ignore_file = '.gitignore'

data/cap-taffy.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cap-taffy}
-  s.version = "1.0.0"
+  s.version = "1.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Henry Hsu"]
@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.description = %q{Capistrano recipes for deploying databases and other common tasks.}
   s.email = %q{henry@qlane.com}
   s.extra_rdoc_files = ["History.txt"]
-  s.files = ["History.txt", "README.md", "Rakefile", "cap-taffy.gemspec", "lib/cap-taffy.rb", "lib/cap-taffy/db.rb", "lib/cap-taffy/parse.rb", "spec/cap-taffy/db_spec.rb", "spec/cap-taffy/parse_spec.rb", "spec/cap-taffy_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.files = ["History.txt", "README.md", "Rakefile", "cap-taffy.gemspec", "lib/cap-taffy.rb", "lib/cap-taffy/db.rb", "lib/cap-taffy/parse.rb", "lib/cap-taffy/ssh.rb", "spec/cap-taffy/db_spec.rb", "spec/cap-taffy/parse_spec.rb", "spec/cap-taffy/ssh_spec.rb", "spec/cap-taffy_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
   s.homepage = %q{http://by.qlane.com}
   s.rdoc_options = ["--main", "README.md"]
   s.require_paths = ["lib"]
@@ -27,16 +27,19 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<taps>, [">= 0"])
       s.add_runtime_dependency(%q<capistrano>, [">= 0"])
       s.add_development_dependency(%q<bones>, [">= 2.5.1"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
     else
       s.add_dependency(%q<heroku>, [">= 0"])
       s.add_dependency(%q<taps>, [">= 0"])
       s.add_dependency(%q<capistrano>, [">= 0"])
       s.add_dependency(%q<bones>, [">= 2.5.1"])
+      s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
     s.add_dependency(%q<heroku>, [">= 0"])
     s.add_dependency(%q<taps>, [">= 0"])
     s.add_dependency(%q<capistrano>, [">= 0"])
     s.add_dependency(%q<bones>, [">= 2.5.1"])
+    s.add_dependency(%q<mocha>, [">= 0"])
   end
 end

data/lib/cap-taffy.rb

@@ -2,7 +2,7 @@
 module CapTaffy
 
   # :stopdoc:
-  VERSION = '1.0.0'
+  VERSION = '1.0.1'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/lib/cap-taffy/db.rb

@@ -6,30 +6,49 @@ rescue LoadError
   error "Install the Taps gem to use db commands. On most systems this will be:\nsudo gem install taps"
 end
 
+require File.join(File.dirname(__FILE__), %w[.. cap-taffy]) unless defined?(CapTaffy)
 require File.join(File.dirname(__FILE__), 'parse')
 require 'digest/sha1'
 
 module CapTaffy::Db
   extend self
 
-  def local(env)
+  # Detects the local database url for +env+.
+  #
+  # Looks for <tt>config/database.yml</tt>.
+  def local_database_url(env)
     return "" unless File.exists?(Dir.pwd + '/config/database.yml')
     db_config = YAML.load(File.read(Dir.pwd + '/config/database.yml'))
 
     CapTaffy::Parse.database_url(db_config, env)
   end
 
-  def remote(instance, env)
+  # Detects the remote database url for +env+ and the current Capistrano +instance+.
+  #
+  # Looks for <tt>config/database.yml</tt> in the +current_path+.
+  def remote_database_url(instance, env)
     db_yml = instance.capture "cat #{instance.current_path}/config/database.yml"
     db_config = YAML::load(db_yml)
 
     CapTaffy::Parse.database_url(db_config, env)
   end
 
+  # The default server port the Taps server is started on.
   def default_server_port
     5000
   end
 
+  # Generates the remote url used by Taps push/pull.
+  #
+  # ==== Parameters
+  # 
+  # * <tt>:login, :password, :host, :port</tt> - See #run.
+  #
+  # ==== Examples
+  #
+  #   login = fetch(:user)
+  #   password = tmp_pass(login)                                               # returns asdkf239udjhdaks (for example)
+  #   remote_url(:login => login, :password => password, :host => 'load-test') # returns http://henry:asdkf239udjhdaks@load-test:5000
   def remote_url(options={})
     host = options[:host]
     port = options[:port] || default_server_port
@@ -39,11 +58,15 @@ module CapTaffy::Db
     url.sub(/\/$/, '')
   end
 
+  # Generates a temporary password to be used for the Taps server command.
   def tmp_pass(user)
     Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{user}--")
   end
 
-  def taps_client(local_database_url, remote_url, &blk)
+  # A quick start for a Taps client.
+  #
+  # <tt>local_database_url</tt> and <tt>remote_url</tt> refer to the options for the Taps gem (see #run).
+  def taps_client(local_database_url, remote_url, &blk) # :yields: client
     Taps::Config.chunksize = 1000
     Taps::Config.database_url = local_database_url
     Taps::Config.remote_url = remote_url
@@ -54,7 +77,11 @@ module CapTaffy::Db
     end
   end
 
-  # server <local_database_url> <login> <password> [--port=N]
+  # Generates the server command used to start a Taps server
+  #
+  # ==== Parameters
+  # * <tt>:remote_database_url, :login, :password</tt> - See #run.
+  # * <tt>:port</tt> - The +port+ the Taps server is on. If given and different from #default_server_port, appends <tt>--port=[port]</tt> to command.
   def server_command(options={})
     remote_database_url, login, password, port = options[:remote_database_url], options[:login], options[:password], options[:port]
     port_argument = ''
@@ -63,7 +90,37 @@ module CapTaffy::Db
     "taps server #{remote_database_url} #{login} #{password}#{port_argument}"
   end
 
-  def run(instance, options = {} , &blk)
+  # The meat of the operation. Runs operations after setting up the Taps server.
+  # 
+  # 1. Runs the <tt>taps</tt> taps command to start the Taps server (assuming Sinatra is running on Thin)
+  # 2. Wait until the server is ready 
+  # 3. Execute block on Taps client
+  # 4. Close the connection(s) and bid farewell.
+  #
+  # ==== Parameters
+  # * <tt>:remote_database_url</tt> - Refers to local database url in the options for the Taps server command (see Taps Options).
+  # * <tt>:login</tt> - The login for +host+. Usually what's in <tt>set :user, "the user"</tt> in <tt>deploy.rb</tt>
+  # * <tt>:password</tt> - The temporary password for the Taps server.
+  # * <tt>:port</tt> - The +port+ the Taps server is on. If not given, defaults to #default_server_port.
+  # * <tt>:local_database_url</tt> - Refers to the local database url in the options for Taps client commands (see Taps Options).
+  #
+  # ==== Taps Options
+  #
+  # <tt>taps</tt>
+  #   server <local_database_url> <login> <password> [--port=N]        Start a taps database import/export server
+  #   pull <local_database_url> <remote_url> [--chunksize=N]           Pull a database from a taps server
+  #   push <local_database_url> <remote_url> [--chunksize=N]           Push a database to a taps server
+  #
+  # ==== Examples
+  #
+  #   task :push do
+  #     login = fetch(:user)
+  #     password = Time.now.to_s
+  #     CapTaffy.Db.run(self, { :login => login, :password => password, :remote_database_url => "sqlite://test_production", :local_database_url => "sqlite://test_development" }) do |client|
+  #       client.cmd_send
+  #     end
+  #   end
+  def run(instance, options = {} , &blk) # :yields: client
     options[:port] ||= default_server_port
     remote_database_url, login, password, port, local_database_url = options[:remote_database_url], options[:login], options[:password], options[:port], options[:local_database_url]
     force_local = options.delete(:local)
@@ -86,12 +143,16 @@ module CapTaffy::Db
     end
   end
 
-  class InvalidURL < RuntimeError; end
+  class InvalidURL < RuntimeError # :nodoc:
+  end
 end
 
 Capistrano::Configuration.instance.load do
   namespace :db do
-    def dry_run_safe(returning = nil, &block)
+    # Executes given block.
+    # If this is a dry run, any raised exceptions will be caught and +returning+ is returned.
+    # If this is not a dry run, any exceptions will be raised as expected.
+    def dry_run_safe(returning = nil, &block) # :yields:
       begin
         yield
       rescue Exception => e
@@ -101,8 +162,8 @@ Capistrano::Configuration.instance.load do
     end
 
     task :detect, :roles => :app do
-      @remote_database_url = dry_run_safe('') { CapTaffy::Db.remote(self, 'production') }
-      @local_database_url = dry_run_safe('') { CapTaffy::Db.local('development') }
+      @remote_database_url = dry_run_safe('') { CapTaffy::Db.remote_database_url(self, 'production') }
+      @local_database_url = dry_run_safe('') { CapTaffy::Db.local_database_url('development') }
     end
 
     desc <<-DESC

data/lib/cap-taffy/parse.rb

@@ -13,6 +13,8 @@ module CapTaffy
       attr_accessor :instance
 
       # Modified from :parse_database_yml in heroku/command/db.rb
+      #
+      # Accepts a complete +db_config+ hash and +env+ and parses for a database_url accordingly.
       def database_url(db_config, env)
         raise Invalid, "please pass me a valid Hash loaded from a database YAML file" unless db_config
         conf = db_config[env]
@@ -33,17 +35,19 @@ module CapTaffy
       end
     end
 
-    def initialize
+    # Override to do nothing on #new
+    def initialize # :nodoc:
 
     end
 
-    # Do nothing
+    # Override to pass-through on #escape
     def escape(string)
       string
     end
 
     public :uri_hash_to_url, :conf_to_uri_hash
 
-    class Invalid < RuntimeError; end
+    class Invalid < RuntimeError # :nodoc:
+    end
   end
 end

data/lib/cap-taffy/ssh.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), %w[.. cap-taffy]) unless defined?(CapTaffy)
+
+module CapTaffy::SSH
+
+end
+
+Capistrano::Configuration.instance.load do
+  namespace :ssh do
+    desc <<-DESC
+      Authorize SSH access for local computer on remote computers(s).
+    DESC
+    task :authorize do
+      public_key = File.read(File.expand_path(File.join(%w[~/ .ssh id_rsa.pub]))).chop
+
+      run %Q[if [ ! -f ~/.ssh/authorized_keys ]; then mkdir -p ~/.ssh && touch ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys; fi && if [ -z "$(grep "^#{public_key}$" ~/.ssh/authorized_keys)" ]; then echo "#{public_key}" >> ~/.ssh/authorized_keys && echo "Public key on '$CAPISTRANO:HOST$' authorized at '#{Time.now.to_s}'"; else echo "Public key on '$CAPISTRANO:HOST$' is already authorized."; fi]
+    end
+  end
+end

data/spec/cap-taffy/db_spec.rb

@@ -22,64 +22,69 @@ module CapTaffy
         load 'lib/cap-taffy/db.rb'
       end
 
-      for_task :detect, :roles => :app, :it => "should be defined" do
-        @db_mod.expects(:remote).returns("remote_db_url")
-        @db_mod.expects(:local).returns("local_db_url")
+      for_task :detect, :roles => :app, :in => :Db, :it => "should be defined" do
+        @mod.expects(:remote_database_url).returns("remote_db_url")
+        @mod.expects(:local_database_url).returns("local_db_url")
         
         load 'lib/cap-taffy/db.rb'
         
-        @namespace_db.instance_variable_get(:@remote_database_url).should == "remote_db_url"
-        @namespace_db.instance_variable_get(:@local_database_url).should == "local_db_url"
+        @namespace.instance_variable_get(:@remote_database_url).should == "remote_db_url"
+        @namespace.instance_variable_get(:@local_database_url).should == "local_db_url"
       end
 
-      for_task :push, :roles => :app, :it => "should send taps client cmd_send" do
+      def load_taffy_db # :nodoc:
+        with_logger do
+          load 'lib/cap-taffy/db.rb'
+        end
+      end
+
+      for_task :push, :roles => :app, :in => :Db, :it => "should send taps client cmd_send" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => nil, :login => "a_user", :password => "a_pass"}
-        @namespace_db.expects(:detect)
+        @namespace.expects(:detect)
         namespace_with_variables(:taps_port => nil)
-        namespace_with_expected_options(options)
-
-        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
-        @db_mod.expects(:run).with(@namespace_db, options).yields(taps_client_who(:expects, :cmd_send))
+        db_with_expected_options(options)
+        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
+        @mod.expects(:run).with(@namespace, options).yields(taps_client_who(:expects, :cmd_send))
 
-        load_taffy
+        load_taffy_db
       end
 
-      for_task :push, :roles => :app, :it => "should use cli argument for port" do
+      for_task :push, :roles => :app, :in => :Db, :it => "should use cli argument for port" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => 1234, :login => "a_user", :password => "a_pass"}
-        @namespace_db.expects(:detect)
+        @namespace.expects(:detect)
         namespace_with_variables(:taps_port => 1234)
-        namespace_with_expected_options(options)
-        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
-        @db_mod.expects(:run).with(@namespace_db, options)
+        db_with_expected_options(options)
+        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
+        @mod.expects(:run).with(@namespace, options)
 
-        load_taffy
+        load_taffy_db
       end
 
-      for_task :push, :roles => :app, :it => "should force 127.0.0.1 (local) for ssh local forwarding" do
+      for_task :push, :roles => :app, :in => :Db, :it => "should force 127.0.0.1 (local) for ssh local forwarding" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => 1234, :login => "a_user", :password => "a_pass"}
-        @namespace_db.expects(:detect)
+        @namespace.expects(:detect)
         namespace_with_variables(:taps_port => 1234, :local => true)
-        namespace_with_expected_options(options)
-        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
-        @db_mod.expects(:run).with(@namespace_db, options.merge(:local => true))
+        db_with_expected_options(options)
+        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
+        @mod.expects(:run).with(@namespace, options.merge(:local => true))
 
-        load_taffy
+        load_taffy_db
       end
       
-      for_task :pull, :roles => :app, :it => "should send taps client cmd_receive" do
+      for_task :pull, :roles => :app, :in => :Db, :it => "should send taps client cmd_receive" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => nil, :login => "a_user", :password => "a_pass"}
-        @namespace_db.expects(:detect)
+        @namespace.expects(:detect)
         namespace_with_variables(:taps_port => nil)
-        namespace_with_expected_options(options)
+        db_with_expected_options(options)
+        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
+        @mod.expects(:run).with(@namespace, options).yields(taps_client_who(:expects, :cmd_receive))
 
-        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
-        @db_mod.expects(:run).with(@namespace_db, options).yields(taps_client_who(:expects, :cmd_receive))
-
-        load_taffy
+        load_taffy_db
       end
     end
 
     context "after capistrano" do
+      include CapistranoHelpers
       include TaffyHelpers
 
       before do
@@ -107,7 +112,7 @@ module CapTaffy
         env = 'test'
         Parse.expects(:database_url).with(@conf, env)
 
-        Db.local(env)
+        Db.local_database_url(env)
       end
 
       it "should detect remote database url" do
@@ -118,7 +123,7 @@ module CapTaffy
         env = 'test'
         Parse.expects(:database_url).with(@conf, env)
 
-        Db.remote(instance, env)
+        Db.remote_database_url(instance, env)
       end
 
       it "should create temporary password from time and user" do
@@ -174,12 +179,12 @@ module CapTaffy
         parser = mock()
         Parse.expects(:new).at_least_once.returns(parser)
         parser.expects(:uri_hash_to_url).
-          with('username' => login, 'password' => password, 'host' => host, 'scheme' => 'http', 'path' => '').returns("remote_url")
+          with('username' => login, 'password' => password, 'host' => host, 'scheme' => 'http', 'path' => '')
       end
 
       it "should build remote url (with some help)" do
         @options[:host] = "127.0.0.1"        
-        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{Db.default_server_port}")
+        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{Db.default_server_port}").returns("remote_url/")
 
         Db.remote_url(@options)
       end
@@ -187,7 +192,7 @@ module CapTaffy
       it "should build remote url with different port" do
         @options[:host] = "127.0.0.1"
         @options[:port] = 1234
-        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{@options[:port]}")
+        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{@options[:port]}").returns("remote_url")
 
         Db.remote_url(@options)
       end
@@ -199,15 +204,15 @@ module CapTaffy
         Db.remote_url(@options).should == "remote_url"
       end
 
-      running_taffy_it "should run with capistrano" do
-        run_capistrano_with(Db.server_command(@options))
+      running_db_it "should run with capistrano" do
+        capistrano_run_with(Db.server_command(@options))
 
         Db.run(@capistrano, @options)
       end
 
-      running_taffy_it "should do something to taps client" do
+      running_db_it "should do something to taps client" do
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:5000, CTRL+C to stop\r\n" do
-          run_capistrano_with(Db.server_command(@options))
+          capistrano_run_with(Db.server_command(@options))
         end
         channel.expects(:close)
 
@@ -220,11 +225,11 @@ module CapTaffy
         channel[:status].should == 0
       end
 
-      running_taffy_it "should run taffy on different port" do
+      running_db_it "should run taffy on different port" do
         @options[:port] = 1234
 
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:1234, CTRL+C to stop\r\n" do
-          run_capistrano_with(Db.server_command(@options))
+          capistrano_run_with(Db.server_command(@options))
         end
         channel.expects(:close)
         Db.expects(:remote_url).with(@options.merge(:host => channel[:host])).returns("remote_url")
@@ -237,9 +242,9 @@ module CapTaffy
         channel[:status].should == 0
       end
 
-      running_taffy_it "should not do anything until taps sinatra server is running" do
+      running_db_it "should not do anything until taps sinatra server is running" do
         simulating_run_loop_with :data => "asdfasdf" do
-          run_capistrano_with(Db.server_command(@options))
+          capistrano_run_with(Db.server_command(@options))
         end
 
         client = mock()
@@ -250,7 +255,7 @@ module CapTaffy
         end
 
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:5000, CTRL+C to stop\r\n" do
-          run_capistrano_with(Db.server_command(@options))
+          capistrano_run_with(Db.server_command(@options))
         end
         channel.expects(:close)
         Db.expects(:remote_url).with(@options.merge(:host => channel[:host], :port => 5000)).returns("remote_url")
@@ -263,9 +268,9 @@ module CapTaffy
         channel[:status].should == 0
       end
 
-      running_taffy_it "should force 127.0.0.1 (local) for remote url" do
+      running_db_it "should force 127.0.0.1 (local) for remote url" do
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:5000, CTRL+C to stop\r\n" do
-          run_capistrano_with(Db.server_command(@options))
+          capistrano_run_with(Db.server_command(@options))
         end
         channel.expects(:close)
 

data/spec/cap-taffy/ssh_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+module CapTaffy
+  describe 'SSH' do
+    include CapistranoHelpers
+
+    before do
+      CapTaffy.send(:remove_const, "SSH") rescue nil
+    end
+
+    it "should load in capistrano configuration instance" do;
+      Capistrano::Configuration.instance.expects(:load)
+
+      load 'lib/cap-taffy/ssh.rb'
+    end
+
+    it "should define :db namespace" do
+      Capistrano::Configuration.instance.expects(:namespace).with(:ssh)
+
+      load 'lib/cap-taffy/ssh.rb'
+    end
+
+    def simulating_line(line, &blk)
+      blk.call.then.yields(line)
+      line
+    end
+
+    for_task :authorize, :in => :SSH, :it => "should authorize on each server" do
+      public_key = "ssh-key2\n"
+      File.expects(:read).with(File.expand_path(File.join(%w[~/ .ssh id_rsa.pub]))).returns(public_key)
+
+      run_with(@namespace, anything) # Don't rly wna test bash scripts
+
+      load 'lib/cap-taffy/ssh.rb'
+    end
+  end
+end

data/spec/cap-taffy_spec.rb

@@ -1,7 +1,4 @@
-
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
 describe CapTaffy do
 end
-
-# EOF

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib cap-taffy]))
 
-module Capistrano
+module Capistrano # :nodoc:
 end
 
 Spec::Runner.configure do |config|
@@ -34,12 +34,19 @@ Capistrano::Configuration.class_eval do
   end
 end
 
+class String # :nodoc:
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+end
+
 module CapistranoHelpers
-  def self.included(base)
+  def self.included(base) # :nodoc:
     base.extend CapistranoHelpers::ClassMethods
   end
 
-  def with_logger(&blk)
+  # Stubs the Capistrano Logger and yields to the block
+  def with_logger(&blk) # :yields:
     logger_class = Class.new
     logger = mock()
     logger.stub_everything
@@ -50,41 +57,83 @@ module CapistranoHelpers
     Capistrano.send(:remove_const, "Logger") rescue nil
   end
 
-  def load_taffy
-    with_logger do
-      load 'lib/cap-taffy/db.rb'
-    end
+  # Helper for common operations in db tasks
+  def db_with_expected_options(options) # :nodoc:
+    @namespace.stubs(:fetch).with(:user).returns(options[:login])
+    @namespace.instance_variable_set(:@remote_database_url, options[:remote_database_url])
+    @namespace.instance_variable_set(:@local_database_url, options[:local_database_url])
   end
 
-  def namespace_with_expected_options(options)
-    @namespace_db.stubs(:fetch).with(:user).returns(options[:login])
-    @namespace_db.instance_variable_set(:@remote_database_url, options[:remote_database_url])
-    @namespace_db.instance_variable_set(:@local_database_url, options[:local_database_url])
+  # Stubs the variables hash used by Capistrano to accept command-line parameters
+  def namespace_with_variables(variables) # :nodoc:
+    @namespace.stubs(:variables).returns(variables)
   end
 
-  def namespace_with_variables(variables)
-    @namespace_db.stubs(:variables).returns(variables)
+  # Creates an expectation for the Capistrano namespace/task <tt>instance</tt> for the <tt>:run</tt> action with <tt>*args</tt>.
+  def run_with(instance, *args)
+    instance.expects(:run).with(*args)
   end
 
+  # The Capistrano <tt>:run</tt> action loops with <tt>channel</tt>, <tt>stream</tt>, and <tt>data</tt> until the channel is closed.
+  # 
+  # Passing in a <tt>:run</tt> expectation, modifies the expectation such that each subsequent invocation ("loop") yields <tt>channel</tt>, <tt>stream</tt>, and <tt>data</tt>
+  #
+  # ==== Parameters
+  #
+  # * <tt>:channel</tt> - A hash containing <tt>:host</tt>.
+  # * <tt>:stream</tt> - A stream object.
+  # * <tt>:data</tt> - A data object, usually a String.
+  def simulating_run_loop_with(options={}, &blk) # :yields:
+    channel = options[:channel] || {:host => "192.168.1.20"}
+    stream = options[:stream]
+    data = options[:data]
+
+    blk.call.then.yields(channel, stream, data)
+    [channel, stream, data]
+  end
 
   module ClassMethods
-    def for_task(task_name, options = {}, &block)
-      message = options.delete(:it)
+    # Used in specs to test Capistrano tasks.
+    #
+    # 
+    # Code defined in the task will be executed automatically on load. (Note the <tt>yields</tt>, see Mocha#yields[http://mocha.rubyforge.org/classes/Mocha/Expectation.html#M000043])
+    #
+    # ==== Parameters
+    #
+    # * <tt>:it</tt> - The description for the current example group.
+    # * <tt>:in</tt> - Specifies the module under test (as well as the namespace the task is defined in). The namespace will be deduced with the downcase of <tt>:in</tt>
+    #
+    # ==== Examples
+    #
+    #   for_task :detect, :roles => :app, :in => :Somewhere, :it => "should so something" do
+    #     @namespace # refers to the current task under test (in Capistrano tasks are executed on Capistrano::Namespaces::Namespace instances)
+    #     @mod       # refers to module CapTaffy::Somewhere
+    #   end
+    def for_task(task_name, options, &block)
+      description = options.delete(:it)
+      namespace = options.delete(:in)
+
       context ":#{task_name.to_s} task" do
         before do
-          @namespace_db = Capistrano::Configuration.instance.namespaces[:db] = mock()
-          @namespace_db.stubs(:desc)
-          @namespace_db.stubs(:task)
-          @namespace_db.expects(:task).with(task_name, options).yields
-
-          @db_mod = Module.new
-          CapTaffy.const_set("Db", @db_mod)
+          @namespace = Capistrano::Configuration.instance.namespaces[namespace.to_s.downcase.to_sym] = mock()
+          @namespace.stubs(:desc)
+          @namespace.stubs(:task)
+          args = [task_name, options]
+          unless options.empty?
+            @namespace.expects(:task).with(*args).yields
+          else
+            @namespace.expects(:task).with(task_name).yields
+          end
+
+          @mod = Module.new # The module under test
+          CapTaffy.const_set(namespace, @mod)
         end
 
-        it message, &block
+        it description, &block
 
         after do
-          CapTaffy.send(:remove_const, "Db")
+          const_name = @mod.to_s.demodulize
+          CapTaffy.send(:remove_const, const_name)
         end
       end
     end
@@ -92,10 +141,14 @@ module CapistranoHelpers
 end
 
 module TaffyHelpers
-  def self.included(base)
+  def self.included(base) # :nodoc:
     base.extend TaffyHelpers::ClassMethods
   end
 
+  # A simple helper for mocking a quick object
+  # 
+  # Usage:
+  #   taps_client_who(:expects, :do_something)
   def taps_client_who(method_symbol, *args)
     client = mock()
     client.send(method_symbol, *args)
@@ -103,24 +156,16 @@ module TaffyHelpers
   end
 
   module ClassMethods
-    def running_taffy_it(message, &blk)
-      context "when running taffy" do
+    # A wrapper for running CapTaffy::Db::run
+    def running_db_it(message, &blk)
+      context "when running db" do
         before do
           @capistrano = mock()
         end
 
-        def run_capistrano_with(*args)
-          @capistrano.expects(:run).with(*args)
-        end
-
-        # invokes one loop of block, passing in channel, stream, data as arguments
-        def simulating_run_loop_with(options={}, &blk)
-          channel = options[:channel] || {:host => "192.168.1.20"}
-          stream = options[:stream]
-          data = options[:data]
-
-          blk.call.then.yields(channel, stream, data)
-          [channel, stream, data]
+        # See CapistranoHelpers
+        def capistrano_run_with(*args)
+          run_with(@capistrano, *args) 
         end
 
         it message, &blk

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hsume2-cap-taffy
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Henry Hsu
@@ -52,6 +52,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.5.1
     version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 description: Capistrano recipes for deploying databases and other common tasks.
 email: henry@qlane.com
 executables: []
@@ -68,13 +78,16 @@ files:
 - lib/cap-taffy.rb
 - lib/cap-taffy/db.rb
 - lib/cap-taffy/parse.rb
+- lib/cap-taffy/ssh.rb
 - spec/cap-taffy/db_spec.rb
 - spec/cap-taffy/parse_spec.rb
+- spec/cap-taffy/ssh_spec.rb
 - spec/cap-taffy_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: false
 homepage: http://by.qlane.com
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --main
@@ -96,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: cap-taffy
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Capistrano recipes for deploying databases (managing database.yml, importing/exporting/transfering databases, etc.)