tdd_deploy 0.0.1

data/Capfile

@@ -0,0 +1,12 @@
+# -*- ruby -*-
+
+set :user, "mike"
+
+role :hosts, "arch"
+#role :hosts, "ubuntu"
+# role :hosts, 'li371-193.members.linode.com'
+
+desc "Test to See if we have root access on hosts"
+task :check_host_access do
+     
+end

data/Gemfile

@@ -0,0 +1,9 @@
+source :rubygems
+
+gem 'ZenTest', "~> 4.5.0"
+# gem 'redgreen'
+gem 'autotest-growl'
+gem 'autotest-fsevent'
+
+gem 'capistrano'
+gem 'net-ping'

data/bin/tdd_deploy_context

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+tdd_lib_path = File.expand_path('../../lib', __FILE__)
+unless $:.include? tdd_lib_path
+  $:.unshift tdd_lib_path
+end
+require 'tdd_deploy/environ'
+# require 'curses'
+
+class TddDeployEnv
+  include TddDeploy::Environ
+
+  attr_accessor :modified
+  
+  def initialize
+    read_env || reset_env
+  end
+
+  def show_env
+    puts "============================================="
+    self.env_types.keys.each do |k|
+      v = self.send(k.to_sym)
+      printf "%-20s: %s\n", k, v
+    end
+    if (self.web_hosts.nil? && self.db_hosts.nil?) || self.web_hosts == self.db_hosts
+      printf "\n\nSpecial Key\n%-20s: %s\n", 'hosts', self.hosts, "set 'hosts' to set both web & db hosts"
+    end
+    puts "\nModified & Not Saved: #{self.modified.join(', ')}\n" if self.modified
+    self.flash
+    "(Env Key OR S[ave] to Save OR Q[uit] Quit + Save OR E[xit] to quit w/o Saving)\n? "
+  end
+
+  def modified?
+    self.modified
+  end
+  
+  def add_to_modified *args
+    @modified ||= []
+    @modified += args
+  end
+  
+  def flash=(value)
+    @flash ||= ''
+    @flash += "#{value}\n"
+  end
+  
+  def flash
+    puts "\n#{@flash}\n\n" if @flash
+    @flash = nil
+  end
+  
+  def save
+    if self.modified?
+      self.flash = 'Updates Saved'
+      self.save_env
+    end
+    self.modified = false
+  end
+
+  def parse_cmd(cmd)
+    puts cmd
+    unless cmd =~ /^\s*(\w+)(\s+.*?)\s*$/i
+      self.flash = "unable to parse command: '#{cmd}'" unless cmd.strip.empty?
+      return
+    end
+    
+    key_prefix = $1
+    param_value = $2.strip
+
+    key_regx = Regexp.new('^' + key_prefix, Regexp::IGNORECASE)
+    matching_keys = self.env_types.keys.select { |k| key_regx.match(k) }
+
+    if matching_keys.size > 1 && matching_keys.include?(key_prefix)
+      matching_keys = [key_prefix]
+    end
+
+    case matching_keys.size
+    when 0
+      if key_prefix == 'hosts'
+        self.hosts = param_value
+        self.flash = "Set hosts to '#{param_value}'"
+        self.add_to_modified('hosts', 'web_hosts', 'db_hosts')
+      else
+        self.flash = "No environment variable matches #{key_prefix}"
+      end
+    when 1
+      key = matching_keys.first
+      self.send "#{key}=".to_sym, param_value
+      self.add_to_modified(key)
+      self.flash = "#{key} updated"
+    else
+      self.flash = "ambiguous match: #{matching_keys.join(', ')}"
+    end
+  end
+end
+
+tdd_deploy_env = TddDeployEnv.new
+
+begin
+  STDOUT.write tdd_deploy_env.show_env
+  STDOUT.flush
+  
+  if STDIN.eof?
+    STDERR.write "Unexpected End of Input - aborting"
+    STDERR.write " - Discarded Unsaved Edits [#{tdd_deploy_env.modified.join(', ')}]" if tdd_deploy_env.modified?
+    STDERR.write "\n"
+    STDERR.flush
+    break
+  end
+  cmd = STDIN.readline.strip
+  puts cmd
+  
+  if cmd =~ /^q(uit)?$/i
+    tdd_deploy_env.save
+    tdd_deploy_env.flash = 'Quit Entered'
+    break
+  elsif cmd =~ /^s(ave)?$/i
+    tdd_deploy_env.save
+  elsif cmd =~ /^e(xit)?$/i
+    tdd_deploy_env.flash = "Exit Entered"
+    tdd_deploy_env.flash = "Discarded Edits [#{tdd_deploy_env.modified.join(', ')}]" if tdd_deploy_env.modified?
+    break
+  else
+    tdd_deploy_env.parse_cmd(cmd)
+  end
+# rescue Exception => e
+#   puts "Rescuing!!!!: #{e}"
+#   exit 1
+end until STDIN.closed?
+
+tdd_deploy_env.flash

data/bin/tdd_deploy_server.rb

@@ -0,0 +1,6 @@
+#! /usr/bin/env ruby
+
+# $:.unshift File.expand_path('../lib', __FILE__)
+CONFIG_RU = File.expand_path('../../config.ru', __FILE__)
+
+system "rackup --debug #{CONFIG_RU}"

data/config.ru

@@ -0,0 +1,6 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+
+require 'rack'
+require 'tdd_deploy/server'
+
+Rack::Server.start :Port => 9292, :app => TddDeploy::Server.new

data/lib/tasks/tdd_deploy.rake

@@ -0,0 +1,24 @@
+require 'fileutils'
+LIB_PATH = File.expand_path('../..', __FILE__)
+LOCAL_TDD_DIR = File.join('lib', 'tdd_deploy')
+
+namespace :tdd_deploy do
+  desc "uninstall removes gem supplied version of tests in lib/tdd_deploy/host_tests & site_tests. Doesn't touch lib/tdd_deploy/local_tests"
+  task :uninstall do
+    ['host_tests', 'site_tests'].each do |target_dir|
+      target_path = File.join(LOCAL_TDD_DIR, target_dir)
+      FileUtils.rm_r target_path if File.exists? target_path
+    end
+  end
+  
+  desc "install tdd_deploy copies tests for hosts and sites from #{LIB_PATH} to lib/tdd_deploy/"
+  task :install do
+    LOCAL_TDD_DIR = File.join('lib', 'tdd_deploy')
+    [ 'lib', LOCAL_TDD_DIR, File.join(LOCAL_TDD_DIR, 'local_tests')].each do |path|
+      Dir.mkdir(path) unless File.exists? path
+    end
+    [ File.join(LIB_PATH, 'tdd_deploy', 'host_tests'), File.join(LIB_PATH, 'tdd_deploy', 'site_tests')].each do |src|
+      FileUtils.cp_r src, LOCAL_TDD_DIR
+    end
+  end
+end

data/lib/tdd_deploy/assertions.rb

@@ -0,0 +1,146 @@
+module TddDeploy
+  module Assertions
+    GREEN = '#0c0'
+    RED   = '#c00'
+    WRAP_ELT_TAG = 'p'
+    # TddDeploy re-implements popular assertions so that they can be used
+    # in multi-host testing.
+    #
+    # These assertions differ from usual TDD assertions in that they do not stop
+    # tests after failing. Rather they continue and accumulate failure counts and messages
+    # which can be displayed using *announce_test_results()*.
+    #
+    # all assertions return boolean *true* or *false*
+
+    # == Stats 
+    #
+    # Stats is a class which acts as a singleton container for test statistics & messages
+    # test_count, messages, failiure count, and failure messages are all instance variables
+    # of Stats. This avoids nasty complications which can come us when using instance,
+    # class, and class-instance variables because the actual variables are defined when they
+    # are initialized - which can easily differ from where they are declared.
+    class Stats
+      class << self
+        attr_accessor :test_count, :failure_count, :failure_messages, :test_messages
+      end
+    end
+
+    # test_results returns the string string of all test messages
+    def test_results
+      unless Stats.failure_count.nil? || Stats.failure_count == 0
+        str = "<#{WRAP_ELT_TAG} style=\"color:#{RED}\">#{Stats.failure_count} Failed Test" + (Stats.failure_count == 1 ? '' : 's') + "</#{WRAP_ELT_TAG}>"
+      else
+        str = "<#{WRAP_ELT_TAG} style=\"color:#{GREEN}\">All Tests Passed</#{WRAP_ELT_TAG}>"
+      end
+      Stats.test_messages ? str + Stats.test_messages.join("\n") : str
+    end
+    
+    def test_failures
+      return '' unless Stats.failure_count > 0
+      "<#{WRAP_ELT_TAG} style=\"color:#{RED}\">Failed #{Stats.failure_count} tests</#{WRAP_ELT_TAG}>\n" + Stats.failure_messages.join("\n")
+    end
+    
+    def test_messages
+      Stats.test_messages
+    end
+    
+    # reset_tests zeros out failure messages and count
+    def reset_tests
+      Stats.test_count = 0
+      Stats.failure_count = 0
+      Stats.failure_messages = []
+      Stats.test_messages = []
+    end
+
+    # Assertions all return true or false. The last parameter is always the assertions
+    # message and is optional.
+    #
+    # assert(prediccate, msg) returns true if prediccate is true, else adds *msg*
+    # to failure messages and returns false
+    def assert predicate, msg
+      assert_primative predicate, msg
+    end
+  
+    def assert_equal expect, value, msg
+      assert_primative expect == value, msg
+    end
+    
+    def assert_match regx, value, msg
+      regx = Regexp.new(regx.to_s) unless regx.instance_of? Regexp
+      assert_primative regx.match(value), msg
+    end
+  
+    def assert_nil value, msg
+      assert_primative value.nil?, msg
+    end
+  
+    def assert_not_nil value, msg
+      assert_primative !value.nil?, msg
+    end
+
+    def assert_raises exception = Exception, msg, &block
+      begin
+        block.call
+      rescue exception => e
+        return true
+      end
+      assert_primative false, msg
+    end
+
+    def refute predicate, msg
+      assert_primative !predicate, msg
+    end
+  
+    def refute_equal expect, value, msg
+      assert_primative expect != value, msg
+    end
+  
+    def pass msg
+      assert_primative true, msg
+    end
+
+    def fail msg
+      assert_primative false, msg
+    end
+
+    # private methods
+    private
+    def assert_primative predicate, msg
+      predicate ? test_passed("Passed: #{msg}") : test_failed("Failed: #{msg}")
+      predicate
+    end
+    
+    # test message handling
+    def test_failed(msg)
+      msg = "<#{WRAP_ELT_TAG} style=\"color:#{RED}\">#{msg}</#{WRAP_ELT_TAG}>"
+      add_failure(msg)
+      add_message(msg)
+    end
+    
+    def test_passed(msg)
+      msg = "<#{WRAP_ELT_TAG} style=\"color:#{GREEN}\">#{msg}</#{WRAP_ELT_TAG}>"
+      add_message(msg)
+    end
+
+    def add_failure(msg)
+      Stats.failure_messages ||= []
+      Stats.failure_count ||= 0
+      Stats.failure_messages.push(msg)
+      Stats.failure_count += 1
+    end
+
+    def add_message(msg)
+      Stats.test_messages ||= []
+      Stats.test_count ||= 0
+      Stats.test_messages.push(msg)
+      Stats.test_count += 1
+    end
+    
+    def self.included(mod)
+      Stats.test_count = 0
+      Stats.failure_count = 0
+      Stats.failure_messages = []
+      Stats.test_messages = []
+    end
+  end
+end

data/lib/tdd_deploy/base.rb

@@ -0,0 +1,62 @@
+require 'tdd_deploy/assertions'
+require 'tdd_deploy/environ'
+require 'tdd_deploy/run_methods'
+require 'tdd_deploy/deploy_test_methods'
+# = TddDeploy
+#
+# TddDeploy provides methods for testing the provisioning of remote hosts
+# and Rails instances running as virtual hosts
+#
+# Tests are simple to write.
+#
+#   Step 1: require 'tdd_deploy' and then subclass TddDeploy::Base
+#   Step 2: write tests using the methods: *run_on_all_hosts* and *run_on_all_hosts_as*
+#   Step 3: run tests and fix installation until all tests pass
+#
+# These tests do not guarantee that anything will work. They only test to see if the files
+# are installed and that communication works to all hosts the site runs on.
+#
+# == TddDeploy::Base
+#
+# TddDeploy::Base is a class which includes all the TddDeploy modules
+# and initializes the environment.
+#
+# it is meant to be subclassed for individual host and site tests.
+#
+#  class HostFacilityTest < TddDeploy::Base
+#     def test_for_file
+#       deploy_test_on_all_hosts_as user_id, match_string_or_regx, err_msg { command }
+#     end
+#     etc
+#   end
+#
+#  NOTE: Derived classes which provide an **initialize** method should call super
+#  to ensure that the environment is set. See TddDeploy::Base to see what the
+#  parent initializer does.
+
+module TddDeploy
+  class Base
+    include TddDeploy::Assertions
+    include TddDeploy::Environ
+    include TddDeploy::RunMethods
+    include TddDeploy::DeployTestMethods
+
+    # args are ignored, unless the args.last is a Hash. If it is passed to *set_env*.
+    # This allows derived classes to have their own arguments as well as allowing
+    # the environment values to modified in a uniform way.
+    def initialize *args
+      self.env_hash || read_env || reset_env
+      set_env(args.pop) if args.last.is_a? Hash
+    end
+    
+    # gather up all descendents so we know what tests to run
+    class <<self
+      attr_accessor :children
+      
+      def inherited(child)
+        self.children ||= []
+        self.children << child
+      end
+    end
+  end
+end

data/lib/tdd_deploy/deploy_test_methods.rb

@@ -0,0 +1,65 @@
+require 'tdd_deploy/assertions'
+require 'tdd_deploy/run_methods'
+
+module TddDeploy
+  module DeployTestMethods
+    include TddDeploy::Assertions
+    include TddDeploy::RunMethods
+    
+    # deploy_test_on_all_hosts runs the command(s) return by '&block' on all hosts in self.hosts
+    # as user 'self.host_admin'.
+    # For each host, an error is declared if EITHER STDOUT does not match 'match_expr_or_str'
+    # OR if the command returns anything on STDERR.
+    # 'match_expr_or_str' can be a Regexp or a string (which will be converted to a Regexp)
+    def deploy_test_on_all_hosts(match_expr_or_str, err_msg, &block)
+      deploy_test_on_all_hosts_as self.host_admin, match_expr_or_str, err_msg, &block
+    end
+
+    # deploy_test_on_all_hosts_as runs the command(s) return by '&block' on all hosts in self.hosts
+    # as the specified user 'userid'.
+    # For each host, an error is declared if EITHER STDOUT does not match 'match_expr_or_str'
+    # OR if the command returns anything on STDERR.
+    # 'match_expr_or_str' can be a Regexp or a string (which will be converted to a Regexp)
+    def deploy_test_on_all_hosts_as(userid, match_expr_or_str, err_msg, &block)
+      ret = true
+      self.hosts.each do |host|
+        ret &= deploy_test_in_ssh_session_as userid, host, match_expr_or_str, err_msg, &block
+      end
+      ret
+    end
+
+    # deploy_test_in_ssh_session host, match_exp_or_string, err_msg, &block runs the command
+    # returned by 'block.call' on the specified host as user 'self.host_admin'.
+    # declares an error if EITHER STDOUT does not match 'match' OR STDERR returns anything
+    # 'match' can be a Regexp or a string (which will be converted to a Regexp)
+    def deploy_test_in_ssh_session(host, match, err_msg, &block)
+      deploy_test_in_ssh_session_as(self.host_admin, host, match, err_msg, &block)
+    end
+
+    # deploy_test_in_ssh_session_as runs the command(s) return by '&block' on the specified host
+    # as user 'userid'
+    # declares an error if EITHER STDOUT does not match 'match' OR STDERR returns anything
+    # 'match' can be a Regexp or a string (which will be converted to a Regexp)
+    def deploy_test_in_ssh_session_as(userid, host, match, err_msg, &block)
+      match = Regexp.new(match) if match.is_a? String
+      raise ArgumentError, 'match expression cannot be empty' if match =~ ''
+
+      rsp, err_rsp, cmd = run_in_ssh_session_as(userid, host, &block)
+
+      result = err_rsp.nil?
+      
+      prefix = "user@host: #{userid}@#{host}"
+
+      fail "<pre>\n#{prefix}: command generated error data:\n" +
+        "  command: #{cmd}\n stdout: '#{rsp}'\n stderr: '#{err_rsp}'\n</pre>" if err_rsp
+
+      if !assert_not_nil rsp, "#{prefix}: stdout is empty for command '#{cmd}'"
+        result &= false
+      elsif !assert_match match, rsp, "#{prefix}: #{err_msg}\n rsp: #{rsp}"
+        result &= false
+      end
+
+      result
+    end
+  end
+end