cap-taffy 0.0.2

data/spec/cap-taffy/db_spec.rb

@@ -0,0 +1,287 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+module CapTaffy
+  describe 'Db' do
+    context "when loaded" do
+      include CapistranoHelpers
+      include TaffyHelpers
+
+      before do
+        CapTaffy.send(:remove_const, "Db") rescue nil
+      end
+
+      it "should load in capistrano configuration instance" do;
+        Capistrano::Configuration.instance.expects(:load)
+
+        load 'lib/cap-taffy/db.rb'
+      end
+
+      it "should define :db namespace" do
+        Capistrano::Configuration.instance.expects(:namespace).with(:db)
+
+        load 'lib/cap-taffy/db.rb'
+      end
+
+      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.instance_variable_get(:@remote_database_url).should == "remote_db_url"
+        @namespace.instance_variable_get(:@local_database_url).should == "local_db_url"
+      end
+
+      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.expects(:detect)
+        namespace_with_variables(:taps_port => nil)
+        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_db
+      end
+
+      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.expects(:detect)
+        namespace_with_variables(:taps_port => 1234)
+        db_with_expected_options(options)
+        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
+        @mod.expects(:run).with(@namespace, options)
+
+        load_taffy_db
+      end
+
+      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.expects(:detect)
+        namespace_with_variables(:taps_port => 1234, :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_db
+      end
+      
+      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.expects(:detect)
+        namespace_with_variables(:taps_port => nil)
+        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))
+
+        load_taffy_db
+      end
+    end
+
+    context "after capistrano" do
+      include CapistranoHelpers
+      include TaffyHelpers
+
+      before do
+        Capistrano::Configuration.instance.expects(:namespace).with(:db)
+        CapTaffy.send(:remove_const, "Db") rescue nil
+        load 'lib/cap-taffy/db.rb'
+
+        @conf = {"test"=>
+          {"reconnect"=>false,
+          "encoding"=>"utf8",
+          "username"=>"root",
+          "adapter"=>"postgresql",
+          "database"=>"test_test",
+          "pool"=>5,
+          "password"=>"root",
+          "host"=>"localhost"}}
+
+        @options = {:remote_database_url => "remote", :local_database_url => "local", :port => nil, :login => "a_user", :password => "a_pass"}
+      end
+
+      it "should detect local database url" do
+        File.expects(:exists?).returns(true)
+        File.expects(:read).returns(mock())
+        YAML.expects(:load).returns(@conf)
+        env = 'test'
+        Parse.expects(:database_url).with(@conf, env)
+
+        Db.local_database_url(env)
+      end
+
+      it "should detect remote database url" do
+        instance = mock()
+        instance.stubs(:current_path).returns("/home/user/public_html/current")
+        instance.expects(:capture).with("cat /home/user/public_html/current/config/database.yml")
+        YAML.expects(:load).returns(@conf)
+        env = 'test'
+        Parse.expects(:database_url).with(@conf, env)
+
+        Db.remote_database_url(instance, env)
+      end
+
+      it "should create temporary password from time and user" do
+        Time.stubs(:now).returns("asdfasdfasdf")
+        user = "me"
+        tmp_pass = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{user}--")
+
+        Db.tmp_pass(user).should == tmp_pass
+      end
+
+      it "should expose a basic taps client" do
+        client = mock()
+        local_database_url = mock()
+        remote_url = mock()
+        Taps::Config.expects(:chunksize=).with(1000)
+        Taps::Config.expects(:database_url=).with(local_database_url)
+        Taps::Config.expects(:remote_url=).with(remote_url)
+        Taps::Config.expects(:verify_database_url)
+        client.expects(:do_something)
+
+        Taps::ClientSession.expects(:quickstart).yields(client)
+
+        Db.taps_client(local_database_url, remote_url) do |client|
+          client.do_something
+        end
+      end
+
+      it "should define default port" do
+        Db.default_server_port.should == 5000
+      end
+
+      it "should build server command" do
+        remote_database_url, login, password, port = @options[:remote_database_url], @options[:login], @options[:password], @options[:port]
+
+        Db.server_command(@options).should == "taps server #{remote_database_url} #{login} #{password}"
+      end
+      
+      it "should build server command with port" do
+        @options[:port] = 1234
+        remote_database_url, login, password, port = @options[:remote_database_url], @options[:login], @options[:password], @options[:port]
+
+        Db.server_command(@options).should == "taps server #{remote_database_url} #{login} #{password} --port=#{port}"
+      end
+      
+      it "should build server command without port if same as default port" do
+        @options[:port] = 5000
+        remote_database_url, login, password = @options[:remote_database_url], @options[:login], @options[:password]
+
+        Db.server_command(@options).should == "taps server #{remote_database_url} #{login} #{password}"
+      end
+
+      def parser_expects_uri_hash_to_url_with(login, password, host)
+        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' => '')
+      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}").returns("remote_url/")
+
+        Db.remote_url(@options)
+      end
+
+      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]}").returns("remote_url")
+
+        Db.remote_url(@options)
+      end
+
+      it "should remove trailing slash from remote url" do
+        @options[:host] = "127.0.0.1"
+        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{Db.default_server_port}").returns("remote_url/")
+
+        Db.remote_url(@options).should == "remote_url"
+      end
+
+      running_db_it "should run with capistrano" do
+        capistrano_run_with(Db.server_command(@options))
+
+        Db.run(@capistrano, @options)
+      end
+
+      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
+          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")
+        Db.expects(:taps_client).with("local", "remote_url").yields(taps_client_who(:expects, :do_something))
+        Db.run(@capistrano, @options) do |client|
+          client.do_something
+        end
+
+        channel[:status].should == 0
+      end
+
+      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
+          capistrano_run_with(Db.server_command(@options))
+        end
+        channel.expects(:close)
+        Db.expects(:remote_url).with(@options.merge(:host => channel[:host])).returns("remote_url")
+        Db.expects(:taps_client).with("local", "remote_url").yields(taps_client_who(:expects, :do_something))
+
+        Db.run(@capistrano, @options) do |client|
+          client.do_something
+        end
+
+        channel[:status].should == 0
+      end
+
+      running_db_it "should not do anything until taps sinatra server is running" do
+        simulating_run_loop_with :data => "asdfasdf" do
+          capistrano_run_with(Db.server_command(@options))
+        end
+
+        client = mock()
+        client.expects(:do_something).never
+
+        Db.run(@capistrano, @options) do |client|
+          client.do_something
+        end
+
+        channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:5000, CTRL+C to stop\r\n" do
+          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")
+        Db.expects(:taps_client).with("local", "remote_url").yields(taps_client_who(:expects, :do_something))
+
+        Db.run(@capistrano, @options) do |client|
+          client.do_something
+        end
+
+        channel[:status].should == 0
+      end
+
+      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
+          capistrano_run_with(Db.server_command(@options))
+        end
+        channel.expects(:close)
+
+        Db.expects(:remote_url).with(@options.merge(:host => '127.0.0.1', :port => 5000)).returns("remote_url")
+        Db.expects(:taps_client).with("local", "remote_url").yields(taps_client_who(:expects, :do_something))
+        Db.run(@capistrano, @options.merge(:local => true)) do |client|
+          client.do_something
+        end
+
+        channel[:status].should == 0
+      end
+    end
+  end
+end

data/spec/cap-taffy/parse_spec.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+require 'lib/cap-taffy/parse'
+
+module CapTaffy
+  describe Parse do
+    before do
+      @database_config = {"production"=>
+                          {"reconnect"=>false,
+                           "encoding"=>"utf8",
+                           "username"=>"root",
+                           "adapter"=>"mysql",
+                           "database"=>"test_production",
+                           "pool"=>5,
+                           "password"=>"root",
+                           "host"=>"localhost"},
+                         "development"=>
+                          {"username"=>"root",
+                           "adapter"=>"sqlite3",
+                           "database"=>"test_development",
+                           "password"=>"root"},
+                         "test"=>
+                          {"reconnect"=>false,
+                           "encoding"=>"utf8",
+                           "username"=>"root",
+                           "adapter"=>"postgresql",
+                           "database"=>"test_test",
+                           "pool"=>5,
+                           "password"=>"root",
+                           "host"=>"localhost"}}
+    end
+
+    it "should do pass-through for escape" do
+      Parse.new.escape("something").should == "something"
+    end
+
+    it "should parse database config for sqlite" do
+      Parse.expects(:conf_to_uri_hash).never
+      Parse.database_url(@database_config, 'development').should == "sqlite://test_development"
+    end
+
+    it "should parse database config for postgresql" do
+      Parse.database_url(@database_config, 'test').should == "postgres://root:root@localhost/test_test?encoding=utf8"
+    end
+
+    it "should parse database config for mysql" do
+      Parse.database_url(@database_config, 'production').should == "mysql://root:root@localhost/test_production?encoding=utf8"
+    end
+    
+    it "should raise invalid conf if so" do
+      lambda { Parse.database_url(nil, nil) }.should raise_error(Parse::Invalid)
+    end
+
+    it "should raise invalid conf if so" do
+      lambda { Parse.database_url(@database_config, nil) }.should raise_error(Parse::Invalid)
+    end
+  end
+end

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

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

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,179 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib cap-taffy]))
+
+module Capistrano # :nodoc:
+end
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+Capistrano.send(:remove_const, "Configuration") rescue nil
+Capistrano.const_set("Configuration", Class.new)
+Capistrano::Configuration.class_eval do
+  def self.instance
+    @instance ||= Capistrano::Configuration.new
+  end
+
+  def load(*args, &block)
+    instance_eval(&block) if block_given?
+  end
+
+  def namespaces
+    @namespaces ||= {}
+  end
+
+  def namespace(name, &block)
+    namespaces[name].instance_eval(&block)
+  end
+end
+
+class String # :nodoc:
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+end
+
+module CapistranoHelpers
+  def self.included(base) # :nodoc:
+    base.extend CapistranoHelpers::ClassMethods
+  end
+
+  # Stubs the Capistrano Logger and yields to the block
+  def with_logger(&blk) # :yields:
+    logger_class = Class.new
+    logger = mock()
+    logger.stub_everything
+    logger_class.stubs(:new).returns(logger)
+    Capistrano.const_set("Logger", logger_class)
+    yield
+  ensure
+    Capistrano.send(:remove_const, "Logger") rescue nil
+  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
+
+  # Stubs the variables hash used by Capistrano to accept command-line parameters
+  def namespace_with_variables(variables) # :nodoc:
+    @namespace.stubs(:variables).returns(variables)
+  end
+
+  # 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
+    # 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 = 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 description, &block
+
+        after do
+          const_name = @mod.to_s.demodulize
+          CapTaffy.send(:remove_const, const_name)
+        end
+      end
+    end
+  end
+end
+
+module TaffyHelpers
+  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)
+    client
+  end
+
+  module ClassMethods
+    # A wrapper for running CapTaffy::Db::run
+    def running_db_it(message, &blk)
+      context "when running db" do
+        before do
+          @capistrano = mock()
+        end
+
+        # See CapistranoHelpers
+        def capistrano_run_with(*args)
+          run_with(@capistrano, *args) 
+        end
+
+        it message, &blk
+
+        after do
+
+        end
+      end
+    end
+  end
+end

data/tasks/ann.rake

@@ -0,0 +1,80 @@
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,20 @@
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF