tdd_deploy 0.0.3 → 0.1.1

data/lib/tdd_deploy/site_tests/site_user.rb

@@ -6,7 +6,7 @@ module TddDeploy
   # tests all hosts to make sure that the local user can log on as *site_user*
   class SiteUser < TddDeploy::Base
     def test_login_as_site_user
-      deploy_test_on_all_hosts_as self.site_user, "/home/#{self.site_user}", "should be able to log into host as #{self.site_user}" do
+      deploy_test_on_hosts_as self.site_user, self.hosts, "/home/#{self.site_user}", "should be able to log into host as #{self.site_user}" do
         'pwd'
       end
     end

data/lib/tdd_deploy/version.rb

@@ -1,3 +1,3 @@
 module TddDeploy
-  VERSION = '0.0.3'
+  VERSION = '0.1.1'
 end

data/tests/test_assertions.rb

@@ -17,31 +17,67 @@ class TestTddDeployAssertionsTestCase < Test::Unit::TestCase
     @assertion_helper = nil
   end
   
+  def test_pass_passes
+    assert @assertion_helper.pass('key', 'passing message'), 'pass passes'
+    assert @assertion_helper.test_results['key'].is_a?(Array), "test_results[key] should be an Array"
+    assert_equal 1, @assertion_helper.test_results['key'].length, "There should be a test_results[key]"
+    assert_equal true, @assertion_helper.test_results['key'].first[0], "pass should be a passing result"
+    assert_match /passing message/, @assertion_helper.test_results['key'].first[1], "pass should have the right success message"
+  end
+
+  def test_fail_fails
+    refute @assertion_helper.fail('key', 'failing message'), 'fail fails'
+    assert @assertion_helper.test_results['key'].is_a?(Array), "test_results[key] should be an Array"
+    assert_equal 1, @assertion_helper.test_results['key'].length, "There should be a test_results[key]"
+    assert_equal false, @assertion_helper.test_results['key'].first[0], "pass should be a passing result"
+    assert_match /failing message/, @assertion_helper.test_results['key'].first[1], "pass should have the right success message"
+  end
+  
+  def test_keying_tests
+    @assertion_helper.pass('key1', 'key1 assertion message')
+    @assertion_helper.fail('key2', 'key2 assertion message')
+    
+    assert @assertion_helper.test_results.keys.include?('key1'), "test messages includes key1"
+    assert @assertion_helper.test_results.keys.include?('key2'), "test messages includes key2"
+    
+    assert_equal 1, @assertion_helper.test_count('key1'), "one test recorded under 'key1'"
+    assert_equal 0, @assertion_helper.failure_count('key1'), "0 failures recorded under 'key1'"
+    
+    assert_equal 1, @assertion_helper.test_count('key2'), "one test recorded under 'key2'"
+    assert_equal 1, @assertion_helper.failure_count('key2'), "1 failure recorded under 'key2'"
+  
+    assert_equal [], @assertion_helper.failure_messages('key1'), "falure_messages('key1') is nil"
+    assert_not_equal [], @assertion_helper.failure_messages('key2'), "falure_messages('key1') is not an empty array"
+    
+    assert_no_match(/key1/, @assertion_helper.test_results['key2'].join('\n'), 'test messages for key2 do not contain key1')
+  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'"
+    assert @assertion_helper.assert('key', true, 'true is true'), 'true tests true'
+    assert @assertion_helper.test_messages('key').first[0], "asserting 'true' passes"
+    assert_match(/Pass/i, @assertion_helper.formatted_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})"
+    refute @assertion_helper.assert('key', false, 'true is true'), "false tests false"
+    refute @assertion_helper.test_messages('key').first[0], "asserting 'false' fails"
+    assert_match /Fail/i, @assertion_helper.formatted_test_results, "test messages should include 'Fail'"
   end
   
   def test_assert_equal
-    assert @assertion_helper.assert_equal(true, true, "true is still true"), "true is true"
+    assert @assertion_helper.assert_equal('key', 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'
+    assert @assertion_helper.assert_match('key', '^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"
+    assert @assertion_helper.assert_nil('key', 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'
+    assert @assertion_helper.assert_not_nil('key', 'foo', 'foo is not nil'), 'foo is not nil'
   end
   
   def test_assert_raises
@@ -49,14 +85,23 @@ class TestTddDeployAssertionsTestCase < Test::Unit::TestCase
   end
   
   def test_refute
-    assert @assertion_helper.refute(false, 'false is false'), 'false is false'
+    assert @assertion_helper.refute('key', 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"
+    assert @assertion_helper.refute_equal('key', false, true, "false is not true"), "false is not true"
   end
   
-  def test_fail
-    refute @assertion_helper.fail('fail returns false'), 'fail returns false'
+  def test_total_failures
+    assert_equal 0, @assertion_helper.total_failures, "no tests results in 0 total failures"
+    @assertion_helper.fail 'key', 'forcing a failure'
+    assert_equal 1, @assertion_helper.total_failures, "failing creates a failure"
+    assert_equal @assertion_helper.total_failures, @assertion_helper.total_tests, "failures == tests"
+    @assertion_helper.fail 'key', 'forcing a failure'
+    assert_equal 2, @assertion_helper.total_failures, "failing creates a failure"
+    
+    @assertion_helper.pass 'key', 'forcing a pass'
+    assert_equal 2, @assertion_helper.total_failures, "failing creates a failure"
+    assert_equal 3, @assertion_helper.total_tests, "passing creates another test"
   end
 end

data/tests/test_configurator.rb

@@ -0,0 +1,34 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'fileutils'
+require 'test/unit'
+require 'tdd_deploy/configurator'
+
+class TestTddDeployConfiguratorTestCase < Test::Unit::TestCase
+  def setup
+    @configurator = TddDeploy::Configurator.new
+  end
+  
+  def teardown
+    @configurator = nil
+  end
+  
+  def test_configurator_is_an_object
+    assert @configurator.is_a?(TddDeploy::Configurator), "@configurator shold be a TddDeploy::Configurator object"
+  end
+  
+  def test_configurator_creates_files
+    FileUtils.rm_rf 'tdd_deploy_configs'
+    @configurator.make_configuration_files
+    assert File.exists?('tdd_deploy_configs'), "tdd_deploy_configs/ exists"
+    [ 'balance_hosts', 'db_hosts', 'web_hosts'].each do |host_dir|
+      host_path = File.join('tdd_deploy_configs', host_dir)
+      assert File.exists?(host_path), "#{host_path} exists"
+      ['config', 'site'].each do |subdir|
+        subdir_path = File.join(host_path, subdir)
+        assert File.exists?(subdir_path), "#{subdir_path} exists"
+        assert Dir.new(subdir_path).entries.length > 2, "#{subdir_path} has 3 or more entries"
+      end
+    end
+  end
+end

data/tests/test_copy_methods.rb

@@ -0,0 +1,106 @@
+$:.unshift File.expand_path('..', __FILE__)
+require 'test_helpers'
+require 'tdd_deploy/environ'
+require 'tdd_deploy/run_methods'
+require 'tdd_deploy/copy_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
+    run_on_hosts_as 'site_user', 'arch', 'rm -f test-file'
+    run_on_hosts_as 'site_user', 'arch', 'rmdir test-dir'
+  end
+
+  def teardown
+    run_on_hosts_as 'site_user', 'arch', 'rm -f test-file'
+    run_on_hosts_as 'site_user', 'arch', 'rmdir test-dir'
+  end
+  
+  def test_mkdir_on_remote_as
+    result = mkdir_on_remote_as 'site_user', 'arch', 'test-dir'
+    assert result, "mkdir_on_remote_as site_user on arch returns true"
+    stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'test -d test-dir && echo "success"'
+    assert_equal "success\n", stdout, "deploy_test_file_exists_on_hosts_as says 'test-dir' exists"
+    
+    stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'rmdir test-dir ; test -d test-dir || echo "success"'
+    assert_equal "success\n", stdout, "deploy_test_file_exists_on_hosts_as says 'test-dir' removed"
+  end
+
+  def test_copy_string_to_remote_file_as
+    str = "line 1\nline 2\nline 3\n"
+    result = copy_string_to_remote_file_as 'site_user', 'arch', str, 'test-file'
+    assert result, "copy_string_to_remote_file_as returns true on success"
+    
+    stdout, stderr, cmd = run_in_ssh_session_on_host_as('site_user', 'arch', 'cat test-file')
+    assert_equal str, stdout, "test-file should exist on arch"
+    assert_nil stderr, "stderr should be nil"
+  end
+
+  def test_copy_file_to_remote_as
+    require 'tempfile'
+    tmp_file = Tempfile.new('foo')
+    begin
+      input_text = "line one\nline two\nline 3\n"
+      tmp_file.write input_text
+      tmp_file.close
+      result = copy_file_to_remote_as 'site_user', 'arch', tmp_file.path, 'test-file'
+    
+      stdout, stderr, cmd = run_in_ssh_session_on_host_as 'site_user', 'arch', 'cat test-file'
+      assert_equal input_text, stdout, "remote file should contain input_text"
+
+      assert result, "copy should return true"
+    ensure
+      tmp_file.unlink
+    end
+  end
+  
+  def test_copy_string_to_remote_on_hosts_as
+    host_list = ['arch']
+    str = "line 1\nline 2\nline 3\n"
+    result = copy_string_to_remote_file_on_hosts_as 'site_user', host_list, str, 'test-file'
+    assert result, "copy_string_to_remote_file_as returns true on success"
+    
+    result = run_on_hosts_as('site_user', host_list, 'cat test-file')
+    refute_nil result, "run_on_hosts_as ran on #{host_list.inspect}"
+    assert_equal str, result['arch'][0], "test-file should exist on arch"
+    assert_nil result['arch'][1], "stderr should be nil"
+  end
+  
+  
+  def test_copy_string_to_remote_on_hosts_as_with_host_list_as_str
+    host_list = 'arch'
+    str = "line 1\nline 2\nline 3\n"
+    result = copy_string_to_remote_file_on_hosts_as 'site_user', host_list, str, 'test-file'
+    assert result, "copy_string_to_remote_file_as returns true on success"
+    
+    result = run_on_hosts_as('site_user', host_list, 'cat test-file')
+    refute_nil result, "run_on_hosts_as ran on #{host_list.inspect}"
+    assert_equal str, result['arch'][0], "test-file should exist on arch"
+    assert_nil result['arch'][1], "stderr should be nil"
+  end
+  
+  
+  def test_copy_file_to_remote_on_hosts_as
+    host_list = ['arch']
+    require 'tempfile'
+    tmp_file = Tempfile.new('foo')
+    begin
+      input_text = "line one\nline two\nline 3\n"
+      tmp_file.write input_text
+      tmp_file.close
+      result = copy_file_to_remote_on_hosts_as 'site_user', host_list, tmp_file.path, 'test-file'
+    
+      results = run_on_hosts_as 'site_user', host_list, 'cat test-file'
+      assert_equal input_text, results['arch'][0], "remote file should contain input_text"
+
+      assert result, "copy should return true"
+    ensure
+      tmp_file.unlink
+    end
+  end
+
+end

data/tests/{test_test_deploy_methods.rb → test_deploy_test_methods.rb}

@@ -36,7 +36,7 @@ class  DeployTestMethodsTestCase < Test::Unit::TestCase
     assert_equal 'local_admin', @tester.local_admin, "local_admin should be 'local_admin'"
     assert_equal 'local_admin@bogus.tld', @tester.local_admin_email, "local_admin_email should be 'local_admin@bogus.tld'"
 #    assert_equal 'hosts', @tester.hosts, "hosts should be 'arch'"
-    assert_equal ['bar', 'foo'], @tester.hosts, "hosts should be 'bar,foo'"
+    assert_equal ['arch'], @tester.hosts, "hosts should be 'arch'"
   end
 
   def test_custom_env
@@ -65,33 +65,45 @@ class  DeployTestMethodsTestCase < Test::Unit::TestCase
     tmp = @tester.deploy_test_in_ssh_session_as 'root', @tester.hosts.first, 'no-file-exists', 'generate an error' do
       'ls /usr/no-file-exists'
     end
-    # @tester.announce_test_results
+    # @tester.announce_formatted_test_results
     @tester.reset_tests
     refute tmp, "run as root should fail when accessing a non-existent file"
 
     tmp = @tester.deploy_test_in_ssh_session_as 'root', @tester.hosts.first, "/root", "should run as root on host #{@tester.hosts.first}" do
       'pwd'
     end
-    # @tester.announce_test_results
+    # @tester.announce_formatted_test_results
     @tester.reset_tests
     assert tmp, "should be able to run on #{@tester.hosts.first} as root"
   end
 
-  def test_deploy_test_in_ssh_session
-    @tester.deploy_test_in_ssh_session @tester.hosts.first, "/home/#{@tester.host_admin}", "can't run as #{@tester.host_admin} on host" do
+  def test_deploy_test_on_hosts_as
+    result = @tester.deploy_test_on_hosts_as 'root', @tester.hosts, '/root', "can't run as root on all hosts" do
       'pwd'
     end
+    assert result, "deploy_test_on_hosts_as works as root on all hosts"
   end
 
-  def test_deploy_test_on_all_hosts_as
-    @tester.deploy_test_on_all_hosts_as 'root', '/root', "can't run as root on all hosts" do
+  def test_deploy_test_on_hosts_as_with_string_for_host_list
+    result = @tester.deploy_test_on_hosts_as 'root', 'arch', '/root', "can't run as root on all hosts" do
       'pwd'
     end
+    assert result, "deploy_test_on_hosts_as works as root on with string for host_list"
   end
+  
+  def test_file_exists_on_hosts_as
+    result = @tester.deploy_test_file_exists_on_hosts_as "root", 'arch', '/no-such-file', "/no-such-file exists on all hosts"
+    refute result, "test_file_exists_on_hosts_as works on arch as root: #{@tester.formatted_test_results}"
 
-  def test_deploy_test_on_all_hosts
-    @tester.deploy_test_on_all_hosts "/home/#{@tester.host_admin}", 'can\'t run on some hosts' do
-      'pwd'
-    end
+    result = @tester.deploy_test_file_exists_on_hosts_as "root", 'arch', '/etc/passwd', "/etc/passwd exists on all hosts"
+    assert result, "test_file_exists_on_hosts_as works on arch as root: #{@tester.formatted_test_results}"
+  end
+  
+  def test_process_running_on_hosts_as
+    result = @tester.deploy_test_process_running_on_hosts_as 'root', 'arch', '/var/run/no-such-pid', "no-such-pid is not running"
+    refute result, "test_process_running_on_hosts works on arch as roots: #{@tester.formatted_test_results}"
+  
+    result = @tester.deploy_test_process_running_on_hosts_as 'root', 'arch','/var/run/crond.pid', "crond is running"
+    assert result, "test_process_running_on_hosts works on arch as root: #{@tester.formatted_test_results}"
   end
 end

data/tests/test_environ.rb

@@ -50,7 +50,8 @@ class TestEnvironTestCase < Test::Unit::TestCase
   
   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,
+      :host_admin, :local_admin, :local_admin_email,
+      :site, :site_user, :site_path, :site_url,
       :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}="
@@ -59,13 +60,13 @@ class TestEnvironTestCase < Test::Unit::TestCase
   
   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|
+    "site", "site_user", "site_path", "site_url", "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|
+    ["host_admin", "local_admin", "local_admin_email", "site", "site_user",  "site_path", "site_url"].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|
@@ -74,23 +75,27 @@ class TestEnvironTestCase < Test::Unit::TestCase
   end
   
   def test_hosts_pseudokey
-    @foo.set_env :web_hosts => '', :db_hosts => ''
+    @foo.set_env :web_hosts => '', :db_hosts => '', :balance_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"
+    assert_equal [], @foo.balance_hosts, "assigning '' to balance_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']"
+    ['web_hosts', 'db_hosts', 'balance_hosts'].each do |hst|
+      assert_equal @foo.send(hst.to_sym), @foo.hosts, "hosts should be same as @foo.#{hst}"
+    end
   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|
+    "site", "site_user", "site_path", "site_url", "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|
+    "site", "site_user", "site_path", "site_url", "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
@@ -105,7 +110,7 @@ class TestEnvironTestCase < Test::Unit::TestCase
       @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|
+    ["host_admin", "local_admin", "local_admin_email", "site", "site_user", "site_path", "site_url"].each do |key|
       tmp = "#{key}-changed"
       @foo.send "#{key}=", tmp
       assert_equal tmp, @foo.send(key.to_sym), "@foo.#{key} should now be #{tmp}"

data/tests/test_remote_ip_tables.rb

@@ -11,6 +11,7 @@ class  RemoteIptablesTestCase < Test::Unit::TestCase
     @tester = TddDeploy::RemoteIpTables.new
     @tester.reset_env
     @tester.set_env :hosts => 'arch', :host_admin => 'mike', :local_admin => 'mike'
+    @tester.reset_tests
   end
 
   def teardown
@@ -18,10 +19,16 @@ class  RemoteIptablesTestCase < Test::Unit::TestCase
   end
 
   def test_tcp_some_blocked_ports
-    assert @tester.tcp_some_blocked_ports
+    @tester.tcp_some_blocked_ports
+    @tester.hosts.each do |host|
+      assert_equal 0, @tester.failure_count(host), "all tested ports blocked for host #{host}"
+    end
   end
-
-  def test_udp_some_blocked_ports
-    assert @tester.udp_some_blocked_ports
+  
+  def test_tcp_some_blocked_ports_non_responsive_host
+    host = 'no-host'
+    @tester.set_env :hosts => host
+    @tester.tcp_some_blocked_ports
+    assert_equal 1, @tester.failure_count(host), "cannot test iptables on non-responding host"
   end
 end

data/tests/test_run_methods.rb

@@ -11,35 +11,52 @@ class RunMethodsTestCase < Test::Unit::TestCase
     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
+
+  def test_ping_host
+    assert ping_host('localhost'), 'can ping local host'
+    assert ping_host('arch'), 'can ping arch'
+    refute ping_host('ubuntu'), 'cannot ping non-running host'
+    refute ping_host('non-existent-host'), 'cannot ping non-existent-host'
+  end
+
+  def test_run_in_ssh_session_on_host_as
+    stdout, stderr, cmd = run_in_ssh_session_on_host_as 'mike', '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'
-  
-    stdout, stderr = run_in_ssh_session_as 'mike', 'no-host' do
-      'pwd'
-    end
+      
+    stdout, stderr = run_in_ssh_session_on_host_as 'mike', 'no-host', 'pwd'
     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
+      
+    stdout, stderr = run_in_ssh_session_on_host_as 'no-user', 'arch', 'pwd'
     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' }
+  def test_run_in_ssh_session_on_host_as
+    stdout, stderr, cmd = run_in_ssh_session_on_host_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'
   end
+    
+  def test_run_on_hosts_as
+    result = run_on_hosts_as 'mike', ['arch', 'arch'], 'pwd'
+    assert_not_nil result, "run_on_hosts_as should not return nil"
+    assert result.is_a?(Hash), "run_on_hosts_as should return an Hash"
+    assert_equal ["/home/mike\n", nil, 'pwd'], result['arch'], "Result['arch'] should have command results"
+    assert_equal 1, result.length, "result length should be 1, not 2"
+  end
+
+  def test_run_on_hosts_as_with_string_for_hosts_list
+    result = run_on_hosts_as 'mike', 'arch', 'pwd'
+    assert_not_nil result, "result should work with a single string for a host list"
+    assert_equal ["/home/mike\n", nil, 'pwd'], result['arch'], "run_on_all_hosts_as should work with string for host list"
+  end
   
   def test_run_on_all_hosts_as
     results = run_on_all_hosts_as('root') { 'pwd'}