tdd_deploy 0.0.1

data/lib/tdd_deploy.rb

@@ -0,0 +1,12 @@
+$:.unshift File.expand_path('..', __FILE__)
+
+require 'tdd_deploy/base'
+require 'tdd_deploy/assertions'
+require 'tdd_deploy/deploy_test_methods'
+require 'tdd_deploy/environ'
+require 'tdd_deploy/run_methods'
+require 'tdd_deploy/version'
+
+if defined? Rails
+  require 'tdd_deploy/railengine'
+end

data/tests/test_assertions.rb

@@ -0,0 +1,62 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/assertions'
+
+class AssertionHelper
+  include TddDeploy::Assertions
+end
+
+class TestTddDeployAssertionsTestCase < Test::Unit::TestCase
+  
+  def setup
+    @assertion_helper = AssertionHelper.new
+    @assertion_helper.reset_tests
+  end
+  
+  def teardown
+    @assertion_helper = nil
+  end
+  
+  def test_assert_true_passes
+    assert @assertion_helper.assert(true, 'true is true'), 'true tests true'
+    assert_match /Pass/i, @assertion_helper.test_results, "test messagess should include 'Pass'"
+  end
+  
+  def test_assert_false_fails
+    refute @assertion_helper.assert(false, 'true is true'), "false tests false"
+    assert_match /Fail/i, @assertion_helper.test_results, "test messages should include 'Fail'"
+    assert_match /1 Failed/, @assertion_helper.test_results, "test messages should count 1 failure (#{@assertion_helper.test_messages})"
+  end
+  
+  def test_assert_equal
+    assert @assertion_helper.assert_equal(true, true, "true is still true"), "true is true"
+  end
+  
+  def test_assert_match
+    assert @assertion_helper.assert_match('^foo$', 'foo', 'foo is not bar'), 'foo is not bar'
+  end
+  
+  def test_assert_nil
+    assert @assertion_helper.assert_nil(nil, "nil is nil"), "nil is nil"
+  end
+  
+  def test_assert_not_nil
+    assert @assertion_helper.assert_not_nil('foo', 'foo is not nil'), 'foo is not nil'
+  end
+  
+  def test_assert_raises
+    assert @assertion_helper.assert_raises(Exception, '1/0 raises something') { 1/0 }, '1/0 raises something'
+  end
+  
+  def test_refute
+    assert @assertion_helper.refute(false, 'false is false'), 'false is false'
+  end
+
+  def test_refute_equal
+    assert @assertion_helper.refute_equal(false, true, "false is not true"), "false is not true"
+  end
+  
+  def test_fail
+    refute @assertion_helper.fail('fail returns false'), 'fail returns false'
+  end
+end

data/tests/test_base.rb

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path('../', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'test_helpers'
+require 'tdd_deploy/base'
+
+module TestBase
+  class Foo < TddDeploy::Base
+  end
+
+  class Bar < TddDeploy::Base
+  end
+end
+
+class TestBaseTestCase < Test::Unit::TestCase
+  def test_tdd_deploy_base_children
+    assert TddDeploy::Base.children.include?(TestBase::Foo), "TddDeploy::Base.children should contain TestBase::Foo"
+    assert TddDeploy::Base.children.include?(TestBase::Bar), "TddDeploy::Base.children should contain TestBase::Bar"
+  end
+end

data/tests/test_colored_tests.rb

@@ -0,0 +1,47 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/base'
+
+# NOTES: These tests require a host to talk to. I run an Arch Linux server on my local
+# machine as a virtual host. Set up your own with appropriate accounts if you need to run
+# these tests.
+
+class ColoredResult < TddDeploy::Base
+  def passing_test
+    deploy_test_on_all_hosts 'true', 'true always passes' do
+      'echo "true"'
+    end
+  end
+  
+  def failing_test
+    deploy_test_on_all_hosts 'false', 'false always fails' do
+      'echo "true"'
+    end
+  end
+end
+
+class  ColoredResultTestCase < Test::Unit::TestCase
+  def setup
+    @tester = ColoredResult.new( { :host_admin => 'mike', :local_admin => 'mike', :db_hosts => 'arch', 
+        :web_hosts => 'arch', :ssh_timeout => 2 } )
+    @tester.reset_tests
+  end
+  
+  def teardown
+    @tester = nil
+    # we need to delete this guy so it doesn't mess up the testing of server.rb
+    TddDeploy::Base.children.delete ColoredResult
+  end
+
+  def test_passing_result
+    @tester.passing_test
+    test_results = @tester.test_results
+    assert_match 'style="color:#0c0"', test_results, "Passing Test result should be colored Green: color:#0c0"
+  end
+
+  def test_failing_result
+    @tester.failing_test
+    test_results = @tester.test_results
+    assert_match 'style="color:#c00"', test_results, "Passing Test result should be colored Red: color:#c00"
+  end
+end

data/tests/test_environ.rb

@@ -0,0 +1,153 @@
+$:.unshift File.expand_path('../', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'test_helpers'
+require 'tdd_deploy/environ'
+
+module TestEnviron
+  class Base
+    include TddDeploy::Environ
+  end
+
+  class Foo < Base
+  end
+
+  class Bar < Base
+  end
+end
+
+class TestEnvironTestCase < Test::Unit::TestCase
+  include TddDeploy::Environ
+
+  def setup
+    @foo = TestEnviron::Foo.new
+    @foo.reset_env
+  end
+  
+  def teardown
+    @foo.reset_env
+    @foo.save_env
+  end
+  
+  def test_exsistence_of_public_methods
+    [:reset_env, :read_env, :reset_env].each do |meth|
+      assert @foo.respond_to?(meth), "@foo should respond to #{meth}"
+    end
+  end
+  def test_response_to_accessors
+    [:env_hash].each do |meth|
+      assert @foo.respond_to?("#{meth}".to_sym), "@foo should respond to #{meth}"
+      assert @foo.respond_to?("#{meth}=".to_sym), "@foo should respond to #{meth}="
+      refute_nil @foo.send(meth), "@foo.#{meth} should not be nil"
+    end
+  end
+  def test_response_to_readers
+    [:env_defaults, :env_types].each do |meth|
+      assert @foo.respond_to?("#{meth}".to_sym), "@foo should respond to #{meth}"
+      refute_nil @foo.send(meth), "@foo.#{meth} should not be nil"
+    end
+  end
+  
+  def test_resonse_to_instance_assessors
+    [:env_hash, :ssh_timeout, :site_base_port, :site_num_servers,
+      :host_admin, :local_admin, :local_admin_email, :site, :site_user,
+      :hosts, :balance_hosts, :db_hosts, :web_hosts].each do |meth|
+      assert @foo.respond_to?(meth), "@foo should respond to #{meth}"
+      assert @foo.respond_to?("#{meth}".to_sym), "@foo should respond to #{meth}="
+    end
+  end
+  
+  def test_env_type
+    ["ssh_timeout", "site_base_port", "site_num_servers", "host_admin", "local_admin", "local_admin_email",
+    "site", "site_user", "balance_hosts", "db_hosts", "web_hosts"].each do |sym|
+      assert @foo.env_types.keys.include?(sym.to_s), "@foo.env_types.keys includes #{sym}"
+    end
+    ["ssh_timeout", "site_base_port", "site_num_servers"].each do |key|
+      assert_equal :int, @foo.env_types[key], "@foo.env_types[#{key}] should be :int"
+    end
+    ["host_admin", "local_admin", "local_admin_email", "site", "site_user"].each do |key|
+      assert_equal :string, @foo.env_types[key], "@foo.env_types[#{key}] should be :string"
+    end
+    ["balance_hosts", "db_hosts", "web_hosts"].each do |key|
+      assert_equal :list, @foo.env_types[key], "@foo.env_types[#{key}] should be :list"
+    end
+  end
+  
+  def test_hosts_pseudokey
+    @foo.set_env :web_hosts => '', :db_hosts => ''
+    assert_equal [], @foo.web_hosts, "assigning '' to web_hosts should create empty list"
+    assert_equal [], @foo.db_hosts, "assigning '' to db_hosts should create empty list"
+    @foo.set_env :hosts => 'foo,bar'
+    assert_equal ['bar', 'foo'], @foo.hosts, "assigning foo,bar to hosts should create ['bar', 'foo']"
+  end
+  
+  def test_env_hash
+    ["ssh_timeout", "site_base_port", "site_num_servers", "host_admin", "local_admin", "local_admin_email",
+    "site", "site_user", "balance_hosts", "db_hosts", "web_hosts"].each do |key|
+      assert_not_nil @foo.env_hash[key], "@foo.env_hash[#{key}] should not be nil"
+    end
+  end
+  
+  def test_env_defaults
+    ["ssh_timeout", "site_base_port", "site_num_servers", "host_admin", "local_admin", "local_admin_email",
+    "site", "site_user", "balance_hosts", "db_hosts", "web_hosts"].each do |key|
+      assert_not_nil @foo.env_defaults[key], "@foo.env_defaults[#{key}] should not be nil"
+    end
+  end
+
+  def test_instance_assignment_accessors
+    assert_equal @foo.env_hash['ssh_timeout'], @foo.ssh_timeout, "@foo.ssh_timeout == @foo.env_hash['ssh_timeout']"
+    ssh_timeout = @foo.ssh_timeout
+    @foo.ssh_timeout += 12
+    assert_equal(ssh_timeout + 12, @foo.ssh_timeout, "@foo.ssh_timeout == #{ssh_timeout + 12}")
+    ["ssh_timeout", "site_base_port", "site_num_servers"].each do |key|
+      tmp = @foo.send(key.to_sym) + 12
+      @foo.send "#{key}=", tmp
+      assert_equal tmp, @foo.send(key.to_sym), "@foo.#{key} should now be #{tmp}"
+    end
+    ["host_admin", "local_admin", "local_admin_email", "site", "site_user"].each do |key|
+      tmp = "#{key}-changed"
+      @foo.send "#{key}=", tmp
+      assert_equal tmp, @foo.send(key.to_sym), "@foo.#{key} should now be #{tmp}"
+    end
+    ["balance_hosts", "db_hosts", "web_hosts"].each do |key|
+      tmp = @foo.send(key.to_sym).join(',') + ',new,values'
+      @foo.send "#{key}=", tmp
+      assert_equal tmp.split(/,/), @foo.send(key.to_sym), "@foo.#{key} should now be #{tmp}"
+    end
+  end
+  
+  def test_instance_level_reset_env
+    tmp = @foo.env_hash['ssh_timeout']
+    @foo.set_env 'ssh_timeout' => 12
+    assert_equal 12, @foo.env_hash['ssh_timeout'], "reset_env should change env_hash"
+    assert_equal 12, @foo.ssh_timeout, "reset_env change should show up in instance method"
+  end
+  
+  def test_instance_env_hash_assign
+    assert_raises(ArgumentError) { @foo.env_hash = 'a string' }
+    assert_raises(ArgumentError) {@foo.env_hash = {'foo' => 'bar'}}
+  end
+  
+  def test_save_env
+    zap_hash = Hash[ @foo.env_types.keys.map { |k| [k, nil] } ]
+    @foo.env_hash = zap_hash
+    @foo.save_env
+    @foo.read_env
+    @foo.env_hash.each do |k, v|
+      case @foo.env_types[k]
+      when :int then expect = 0
+      when :string then expect = ''
+      when :list then expect = []
+      end
+      assert_equal expect, @foo.env_hash[k], "After Zapping, env_hash['#{k}'] should be #{expect}"
+      assert_equal expect, @foo.send(k.to_sym), "After Zapping, @foo.#{k} should be #{expect}"
+    end
+  end
+
+  def test_transfer_env
+    @foo.ssh_timeout = 401
+    bar = TestEnviron::Bar.new
+    assert_equal 401, bar.ssh_timeout, "Setting env in one object should transfer to another"
+  end
+end

data/tests/test_helpers.rb

@@ -0,0 +1,10 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+# Add bundler setup to load path
+require 'rubygems'
+require 'bundler/setup'
+# $:.each { |x| puts x }
+
+require 'test/unit'
+require 'net/ssh'
+require 'capistrano'

data/tests/test_host_tests.rb

@@ -0,0 +1,31 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/host_tests/host_connection'
+
+# NOTES: These tests require a host to talk to. I run an Arch Linux server on my local
+# machine as a virtual host. Set up your own with appropriate accounts if you need to run
+# these tests.
+
+class  HostTestsTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::HostConnection.new
+    @tester.reset_env
+    @tester.set_env :web_hosts => 'arch', :db_hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+  end
+  
+  def teardown
+    @tester = nil
+  end
+
+  def test_ping
+    assert @tester.ping, "Can ping #{@tester.hosts.join(',')}"
+  end
+  
+  def test_ssh_login
+    assert @tester.ssh_login, "Can login #{@tester.hosts.join(',')} as #{@tester.host_admin}"
+  end
+  
+  def test_ssh_login_as_root
+    assert @tester.ssh_login_as_root, "Can login to #{@tester.hosts.join(',')} as root"
+  end
+end

data/tests/test_remote_ip_tables.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/host_tests/remote_ip_tables'
+
+# NOTES: These tests require a host to talk to. I run an Arch Linux server on my local
+# machine as a virtual host. Set up your own with appropriate accounts if you need to run
+# these tests.
+
+class  RemoteIptablesTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::RemoteIpTables.new
+    @tester.reset_env
+    @tester.set_env :hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+  end
+
+  def teardown
+    @tester = nil
+  end
+
+  def test_tcp_some_blocked_ports
+    assert @tester.tcp_some_blocked_ports
+  end
+
+  def test_udp_some_blocked_ports
+    assert @tester.udp_some_blocked_ports
+  end
+end

data/tests/test_remote_monit.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/host_tests/remote_monit'
+
+# NOTES: These tests require a host to talk to. I run an Arch Linux server on my local
+# machine as a virtual host. Set up your own with appropriate accounts if you need to run
+# these tests.
+
+class  RemoteMonitTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::RemoteMonit.new
+    @tester.reset_env
+    @tester.set_env :hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+  end
+  
+  def teardown
+    @tester = nil
+  end
+
+  def test_monit_installed
+    assert @tester.test_monit_installed, "monit is installed"
+  end
+
+  def test_monit_running
+    assert @tester.test_monit_running, "monit is running"
+  end
+end

data/tests/test_remote_nginx.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/host_tests/remote_nginx'
+
+# NOTES: These tests require a host to talk to. I run an Arch Linux server on my local
+# machine as a virtual host. Set up your own with appropriate accounts if you need to run
+# these tests.
+
+class  RemoteNginxTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::RemoteNginx.new
+    @tester.reset_env
+    @tester.set_env :hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+  end
+  
+  def teardown
+    @tester = nil
+  end
+
+  def test_nginx_installed
+    assert @tester.test_nginx_installed, 'nginx installed'
+  end
+
+  def test_nginx_running
+    assert @tester.test_nginx_running, 'nginx is running'
+  end
+end

data/tests/test_remote_postfix.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/host_tests/remote_postfix'
+
+# NOTES: These tests require a host to talk to. I run an Arch Linux server on my local
+# machine as a virtual host. Set up your own with appropriate accounts if you need to run
+# these tests.
+
+class  RemotePostfixTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::RemotePostfix.new
+    @tester.reset_env
+    @tester.set_env :hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+  end
+  
+  def teardown
+    @tester = nil
+  end
+
+  def test_postfix_installed
+    assert @tester.test_postfix_installed, "postfix is installed"
+  end
+
+  def test_postfix_running
+    assert @tester.test_postfix_running, "postfix is running"
+  end
+end

data/tests/test_remote_postgresql.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/host_tests/remote_postgresql'
+
+# NOTES: These tests require a host to talk to. I run an Arch Linux server on my local
+# machine as a virtual host. Set up your own with appropriate accounts if you need to run
+# these tests.
+
+class  RemotePostgresqlTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::RemotePostgresql.new
+    @tester.reset_env
+    @tester.set_env :hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+  end
+  
+  def teardown
+    @tester = nil
+  end
+
+  def test_postgresql_installed
+    assert @tester.test_postgresql_installed, "postgresql is installed"
+  end
+
+  def test_postgreql_running
+    assert @tester.test_postgresql_running, "postgresql is running"
+  end
+end

data/tests/test_run_methods.rb

@@ -0,0 +1,89 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/environ'
+require 'tdd_deploy/run_methods'
+
+class RunMethodsTestCase < Test::Unit::TestCase
+  include TddDeploy::Environ
+  include TddDeploy::RunMethods
+
+  def setup
+    self.reset_env
+    self.set_env :hosts => 'arch,ubuntu', :host_admin => 'mike', :ssh_timeout => 2
+  end
+  
+  def test_run_in_ssh_session_as
+    stdout, stderr, cmd = run_in_ssh_session_as 'mike', 'arch' do
+      'pwd'
+    end
+    assert_equal "/home/mike\n", stdout, "should be able to run as mike on host arch"
+    assert_nil stderr, "should not return error if can connect to host"
+    assert_equal 'pwd', cmd, 'cmd should be pwd'
+  
+    stdout, stderr = run_in_ssh_session_as 'mike', 'no-host' do
+      'pwd'
+    end
+    refute_equal "/home/mike\n", stdout, "should not return home directory for bad host name"
+    refute_nil stderr, "should return an error message for bad host name"
+    assert_equal 'pwd', cmd, 'cmd should be pwd'
+  
+    stdout, stderr = run_in_ssh_session_as 'no-user', 'arch' do
+      'pwd'
+    end
+    refute_equal "/home/mike\n", stdout, "should not return home directory for bad user name"
+    refute_nil stderr, "should return an error message for bad user name"
+  end
+  
+  def test_run_in_ssh_session
+    stdout, stderr, cmd = run_in_ssh_session('arch') { 'pwd' }
+    assert_equal "/home/mike\n", stdout, "should be able to run as mike on host arch"
+    assert_nil stderr, "should not return error if can connect to host"
+    assert_equal 'pwd', cmd, 'cmd should be pwd'
+  end
+  
+  def test_run_on_all_hosts_as
+    results = run_on_all_hosts_as('root') { 'pwd'}
+    refute_nil results, "results should not be nil"
+    assert results.is_a?(Hash), "results should be a Hash"
+    assert_equal 2, results.size, "results should have two entries"
+    
+    assert_equal "/root\n", results['arch'][0], "should run correctly on arch"
+    assert_nil results['arch'][1], "no errors on arch"
+    assert_equal results['arch'][2], 'pwd', 'cmd should be pwd'
+    
+    assert_nil results['ubuntu'][0], "no stdout for ubuntu"
+    refute_nil results['ubuntu'][1], 'failure message for ubuntu'
+    assert_equal results['ubuntu'][2], 'pwd', 'cmd should be pwd'
+  end
+  
+  def test_run_on_all_hosts
+    results = run_on_all_hosts { 'pwd' }
+  
+    assert_equal "/home/mike\n", results['arch'][0], "should run correctly on arch"
+    assert_nil results['arch'][1], "no errors on arch"
+    assert_equal results['arch'][2], 'pwd', 'cmd should be pwd'
+    
+    assert_nil results['ubuntu'][0], "no stdout for ubuntu"
+    refute_nil results['ubuntu'][1], 'failure message for ubuntu'
+    assert_equal results['ubuntu'][2], 'pwd', 'cmd should be pwd'
+  end
+  
+  def test_run_locally
+    stdout, stderr, cmd = run_locally { 'echo foo' }
+    assert_equal "foo\n", stdout, "echo foo should echo foo\\n"
+    assert_nil stderr, "stderr should be nil"
+    assert_equal 'echo foo', cmd, "cmd should be 'echo foo'"
+  
+    stdout, stderr, cmd = run_locally { 'bad-command foo' }
+    assert_nil stdout, "stdout should be nil for bad command"
+    refute_nil stderr, "stderr should not be nil"
+    assert_equal 'bad-command foo', cmd, "cmd should be 'bad-command foo'"
+  end
+  
+  def test_run_locally_with_input
+    input_text = "one line of text\n"
+    stdout, stderr, cmd = run_locally(input_text) { 'cat -' }
+    assert_equal input_text, stdout, "command should echo input: '#{input_text}"
+    assert_nil stderr, "command should not generate errs"
+  end
+end

data/tests/test_server.rb

@@ -0,0 +1,46 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'test/unit'
+require 'tdd_deploy/run_methods'
+
+class TestServerTestCase < Test::Unit::TestCase
+  GEM_ROOT = File.expand_path('../..', __FILE__)
+  BIN_DIR = File.join(GEM_ROOT, 'bin')
+  PORT = 8809
+
+  include TddDeploy::RunMethods
+  
+  def setup
+    require 'tdd_deploy/server'
+    @tester = TddDeploy::Server.new(PORT, :web_hosts => 'arch', :db_hosts => 'arch', 
+      :host_admin => 'mike', :local_admin => 'mike', :ssh_timeout => 2)
+  end
+  
+  def teardown
+    @tester = nil
+  end
+  
+  def test_tester_accessors
+    assert_equal PORT, @tester.port, "@tester.port should be #{PORT}"
+  end
+  
+  def test_classes_array
+    @tester.load_all_tests
+    assert_not_nil @tester.test_classes, "@tester.test_classes should not be nil"
+    assert @tester.test_classes.include?(TddDeploy::HostConnection), "@tester.test_classes should contain TddDeploy::HostConnection"
+  end
+  
+  def test_run_all_tests
+    ret = @tester.run_all_tests
+    assert ret, "@tester should run all tests and return true: #{@tester.test_failures}"
+    # puts @tester.test_results
+  end
+  
+  def test_rack_interface
+    code, headers, body = @tester.call({})
+    assert_equal 200, code, "@tester always responds with 200"
+    assert_not_nil body, "body should not be nil"
+    assert_equal 'text/html', headers['Content-Type'], "Content-Type is text/html"
+    assert_equal headers['Content-Length'].to_i, body.join('').length, "Content-Length is the size of body"
+  end
+end

data/tests/test_site_layout.rb

@@ -0,0 +1,34 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/site_tests/site_layout'
+
+class TestSiteLayoutTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::SiteLayout.new
+    @tester.reset_env
+    @tester.set_env :hosts => 'arch'
+    @tester.reset_tests
+  end
+
+  def teardown
+    @tester = nil
+  end
+
+  def test_site_home
+    assert @tester.test_site_subdir, "Directory /home/#{@tester.site_user}/#{@tester.site} should exist"
+  end
+  
+  def test_site_releases
+    assert @tester.test_releases_subdir, "Directory /home/#{@tester.site_user}/#{@tester.site}/releases should exist"
+  end
+  
+  def test_site_nginx_conf
+    assert @tester.test_nginx_conf, "Directory /home/#{@tester.site_user}/nginx_conf should exist"
+  end
+  
+  def test_site_monitrc
+    assert @tester.test_monitrc, "Directory /home/#{@tester.site_user}/monitrc should exist"
+  end
+end
+
+

data/tests/test_site_user.rb

@@ -0,0 +1,21 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/site_tests/site_user'
+
+class TestSiteUserTestCase < Test::Unit::TestCase
+  def setup
+    @tester = TddDeploy::SiteUser.new
+    @tester.reset_env
+    @tester.set_env :hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+  end
+
+  def teardown
+    @tester = nil
+  end
+
+  def test_login_as_site_user
+    assert @tester.test_login_as_site_user, "Unable to login to some hosts as #{@tester.site_user}"
+  end
+end
+
+