syncwrap 1.5.2 → 2.0.0

data/test/test_context_rput.rb

@@ -0,0 +1,289 @@
+#!/usr/bin/env jruby
+#.hashdot.profile += jruby-shortlived
+
+#--
+# Copyright (c) 2011-2014 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require_relative 'setup'
+
+require 'syncwrap'
+
+class TestContextRput < MiniTest::Unit::TestCase
+  include SyncWrap
+
+  VERBOSE = ARGV.include?( '--verbose' )
+
+  TEST_DIR = File.dirname( __FILE__ ).freeze
+  SYNC_DIR = File.join( TEST_DIR, 'sync' ).freeze
+  SYNC_PATHS = [ SYNC_DIR ].freeze
+
+  def setup
+    FileUtils.rm_rf( "#{TEST_DIR}/d1" )
+    FileUtils.rm_rf( "#{TEST_DIR}/d2" )
+    FileUtils.rm_rf( "#{TEST_DIR}/d3" )
+    FileUtils.rm_rf( "#{TEST_DIR}/baz" )
+  end
+
+  class TestContext < Context
+    attr_accessor :rsync_count
+
+    def initialize( *args )
+      @rsync_count = 0
+      super
+    end
+    def rsync( *args )
+      @rsync_count += 1
+      super
+    end
+  end
+
+  def sp
+    @sp ||= Space.new.tap do |s|
+      s.merge_default_options( sync_paths: SYNC_PATHS,
+                               erb_binding: binding_under_test )
+      s.merge_default_options( verbose: :v ) if VERBOSE
+    end
+  end
+
+  def test_rput_file
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd1/bar', "#{TEST_DIR}/d2/" )
+        if i == 0
+          assert_equal( %w[ bar ], changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        assert_equal( IO.read( "#{SYNC_DIR}/d1/bar" ),
+                      IO.read( "#{TEST_DIR}/d2/bar" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_file_sudo
+    skip unless TestOptions::SAFE_SUDO
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd1/bar', "#{TEST_DIR}/d2/", user: ENV['USER'] )
+        if i == 0
+          assert_equal( %w[ bar ], changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        assert_equal( IO.read( "#{SYNC_DIR}/d1/bar" ),
+                      IO.read( "#{TEST_DIR}/d2/bar" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_erb_no_suffix
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd1/foo', "#{TEST_DIR}/d2/" )
+        if i == 0
+          assert_equal( %w[ foo ], changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        assert_equal( "barfoobar\n",
+                      IO.read( "#{TEST_DIR}/d2/foo" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_erb_suffix
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd1/foo.erb', "#{TEST_DIR}/d2/" )
+        if i == 0
+          assert_equal( %w[ foo ], changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        assert_equal( "barfoobar\n",
+                      IO.read( "#{TEST_DIR}/d2/foo" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_erb_rename
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd1/foo.erb', "#{TEST_DIR}/baz" )
+        if i == 0
+          assert_equal( %w[ foo ], changes.map { |c| c[1] } )
+          refute( File.exist?( "#{TEST_DIR}/foo" ) )
+        else
+          assert_empty( changes )
+        end
+        assert_equal( "barfoobar\n",
+                      IO.read( "#{TEST_DIR}/baz" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_missing_dir
+    host = sp.host( 'localhost' )
+    ctx = TestContext.new( host, sp.default_options )
+    begin
+      ctx.rput( 'nodir/', "#{TEST_DIR}/" )
+      flunk "Expected SourceNotFound exception"
+    rescue SourceNotFound => e
+      refute_match( /.erb/, e.message )
+      pass
+    end
+    assert_equal( 0, ctx.rsync_count )
+  end
+
+  def test_rput_missing_file
+    host = sp.host( 'localhost' )
+    ctx = TestContext.new( host, sp.default_options )
+    begin
+      ctx.rput( 'd1/goo', "#{TEST_DIR}/" )
+      flunk "Expected SourceNotFound exception"
+    rescue SourceNotFound => e
+      refute_match( /.erb/, e.message )
+      pass
+    end
+    assert_equal( 0, ctx.rsync_count )
+  end
+
+  def test_rput_contents_with_erb
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd1/', "#{TEST_DIR}/d2" )
+        if i == 0
+          assert_equal( %w[ ./ bar foo ], changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        assert_equal( IO.read( "#{SYNC_DIR}/d1/bar" ),
+                      IO.read( "#{TEST_DIR}/d2/bar" ) )
+        assert_equal( "barfoobar\n",
+                      IO.read( "#{TEST_DIR}/d2/foo" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_dir_with_erb
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd1', "#{TEST_DIR}" )
+        if i == 0
+          assert_equal( %w[ d1/ d1/bar d1/foo ], changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        refute( File.executable?( "#{TEST_DIR}/d1/bar" ) )
+        assert_equal( IO.read( "#{SYNC_DIR}/d1/bar" ),
+                      IO.read( "#{TEST_DIR}/d1/bar" ) )
+        refute( File.executable?( "#{TEST_DIR}/d1/foo" ) )
+        assert_equal( "barfoobar\n",
+                      IO.read( "#{TEST_DIR}/d1/foo" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_subdir_with_erb
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd3', "#{TEST_DIR}" )
+        if i == 0
+          assert_equal( %w[ d3/ d3/d2/ d3/d2/bar d3/d2/foo ],
+                        changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        assert( File.executable?( "#{TEST_DIR}/d3/d2/bar" ) )
+        assert_equal( IO.read( "#{SYNC_DIR}/d3/d2/bar" ),
+                      IO.read( "#{TEST_DIR}/d3/d2/bar" ) )
+        assert( File.executable?( "#{TEST_DIR}/d3/d2/foo" ) )
+        assert_equal( "barfoobar\n",
+                      IO.read( "#{TEST_DIR}/d3/d2/foo" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_subdir_contents_with_erb
+    host = sp.host( 'localhost' )
+    2.times do |i|
+      ctx = TestContext.new( host, sp.default_options )
+      ctx.with do
+        changes = ctx.rput( 'd3/', "#{TEST_DIR}" )
+        if i == 0
+          assert_equal( %w[ d2/ d2/bar d2/foo ], changes.map { |c| c[1] } )
+        else
+          assert_empty( changes )
+        end
+        assert( File.executable?( "#{TEST_DIR}/d2/bar" ) )
+        assert_equal( IO.read( "#{SYNC_DIR}/d3/d2/bar" ),
+                      IO.read( "#{TEST_DIR}/d2/bar" ) )
+        assert( File.executable?( "#{TEST_DIR}/d2/foo" ) )
+        assert_equal( "barfoobar\n",
+                      IO.read( "#{TEST_DIR}/d2/foo" ) )
+      end
+      assert_equal( 1, ctx.rsync_count )
+    end
+  end
+
+  def test_rput_erb_perm_change_only
+    host = sp.host( 'localhost' )
+    ctx = TestContext.new( host, sp.default_options )
+    changes = ctx.rput( 'd3/', "#{TEST_DIR}" )
+    assert_equal( %w[ d2/ d2/bar d2/foo ], changes.map { |c| c[1] } )
+    assert( File.executable?( "#{TEST_DIR}/d2/foo" ) )
+    assert_equal( 1, ctx.rsync_count )
+
+    # Make the template target non-executable temporarily. On re-rput,
+    # only change is that file should have its exec bits reset.
+    ctx = TestContext.new( host, sp.default_options )
+    FileUtils.chmod( 0664, "#{TEST_DIR}/d2/foo" )
+    changes = ctx.rput( 'd3/', "#{TEST_DIR}" )
+    assert_equal( [ %w[ .f...p..... d2/foo ] ], changes )
+    assert( File.executable?( "#{TEST_DIR}/d2/foo" ) )
+    assert_equal( 1, ctx.rsync_count )
+  end
+
+  def binding_under_test
+    var = "foo"
+    binding
+  end
+
+end

data/test/test_rsync.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/env jruby
+#.hashdot.profile += jruby-shortlived
+
+#--
+# Copyright (c) 2011-2014 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require_relative 'setup'
+
+require 'syncwrap'
+require 'syncwrap/rsync'
+
+class TestRsync < MiniTest::Unit::TestCase
+  include SyncWrap::Rsync
+
+  def test_expand_implied_target
+    assert_expand( %w[ other/lang.sh /etc/],
+                   %w[ other/lang.sh /etc/] )
+
+    assert_expand( %w[ etc/profile.d/lang.sh /etc/profile.d/ ],
+                   %w[ etc/profile.d/lang.sh ] )
+
+    assert_expand( %w[ etc/profile.d/ /etc/profile.d/ ],
+                   %w[ etc/profile.d/ ] )
+
+    assert_expand( %w[ etc/profile.d /etc/ ],
+                   %w[ etc/profile.d ] )
+  end
+
+  def test_user_options
+    assert_opts( [ '--rsync-path=sudo rsync' ], user: 'root' )
+    assert_opts( [ '--rsync-path=sudo rsync' ], user: :root )
+    assert_opts( [ '--rsync-path=sudo -u runr rsync' ], user: 'runr' )
+  end
+
+  def test_exclude_options
+    assert_opts( %w[ --cvs-exclude ], excludes: :dev )
+    assert_opts( %w[ --cvs-exclude ], excludes: [ :dev ] )
+    assert_opts( %w[ --exclude=foo ], excludes: 'foo' )
+    assert_opts( %w[ --exclude=foo --exclude=bar ], excludes: %w[ foo bar ] )
+  end
+
+  def test_ssh_options
+    assert_opts( [ '-e', 'ssh -l auser' ], ssh_user: 'auser' )
+    assert_opts( [], ssh_user_pem: 'key.pem' )
+    assert_opts( [ '-e', 'ssh -l auser -i key.pem' ],
+                 ssh_user: 'auser', ssh_user_pem: 'key.pem' )
+    assert_opts( [ '-e', 'ssh -o foo=bar' ], ssh_options: {'foo'=>'bar'} )
+  end
+
+  def test_other_options
+    assert_opts( %w[ -n ], dryrun: true )
+  end
+
+  def test_localhost
+    args = rsync_args( 'localhost', ['d'], 'd/' )
+    assert_equal( %w[rsync -i -r -l -E -c -b d d/], args )
+  end
+
+  def assert_expand( expected, args )
+    expanded = expand_implied_target( args )
+    assert_equal( expected, expanded.flatten, expanded )
+  end
+
+  def assert_opts( expected, opts )
+    args = rsync_args( 'testhost', ['d'], 'd/', opts )
+    assert_equal( %w[rsync -i -r -l -E -c -b] +
+                  expected +
+                  %w[d testhost:d/],
+                  args )
+  end
+
+  SYNC_DIR = File.join( SyncWrap::GEM_ROOT, 'sync' ).freeze
+  SYNC_PATHS = [ SYNC_DIR ].freeze
+
+  # Maintenance: We use gem's sync/src/hashdot template list for
+  # testing, so expect breakage if that changes.
+  SYNC_HASHDOT = ( SYNC_DIR + '/src/hashdot' ).freeze
+
+  def test_relativize
+    rel = relativize( SYNC_HASHDOT )
+    assert_operator( rel, :!=, SYNC_HASHDOT )
+    assert( File.identical?( SYNC_HASHDOT, rel ) )
+    assert_equal( rel, relativize( rel ) )
+    assert_equal( rel + '/', relativize( rel + '/' ) )
+  end
+
+  def test_subpath
+    assert_equal( "",    subpath( "d/",     "d/f" ) )
+    assert_equal( "",    subpath( "d",      "d/f" ) )
+    assert_equal( "",    subpath( "d/e/",   "d/e/f" ) )
+    assert_equal( "",    subpath( "d/e/d/", "d/e/d/f" ) )
+    assert_equal( "e",   subpath( "d",      "d/e/f" ) )
+    assert_equal( "e",   subpath( "d/e",    "d/e/f" ) )
+    assert_equal( "e/d", subpath( "d",      "d/e/d/f" ) )
+    assert_equal( "e/d", subpath( "d/",     "d/e/d/f" ) )
+    assert_equal( "e/d", subpath( "d/e" ,   "d/e/d/f" ) )
+    assert_equal( "d",   subpath( "d/e/",   "d/e/d/f" ) )
+  end
+
+  def test_resolve_sources
+    src = resolve_source!( 'src/hashdot', SYNC_PATHS )
+    assert( File.identical?( SYNC_HASHDOT, src ), src )
+    assert( src[-1] != '/' )
+
+    src = resolve_source!( 'src/hashdot/', SYNC_PATHS )
+    assert( File.identical?( SYNC_HASHDOT, src ), src )
+    assert( src[-1] == '/' )
+
+    assert_raises( SyncWrap::SourceNotFound ) do
+      resolve_sources( [ 'src/hashdot', 'not/found' ], SYNC_PATHS )
+    end
+
+    src = resolve_source!( 'src/hashdot', [ '/bogus' ] + SYNC_PATHS )
+    assert( File.identical?( SYNC_HASHDOT, src ), src )
+  end
+
+  def test_find_source_erbs
+    erbs = find_source_erbs( SYNC_HASHDOT ).sort
+    assert_equal( [ SYNC_HASHDOT + '/Makefile.erb',
+                    SYNC_HASHDOT + '/profiles/default.hdp.erb',
+                    SYNC_HASHDOT + '/profiles/jruby.hdp.erb' ],
+                  erbs )
+  end
+
+end

data/test/test_shell.rb

@@ -0,0 +1,233 @@
+#!/usr/bin/env jruby
+#.hashdot.profile += jruby-shortlived
+
+#--
+# Copyright (c) 2011-2014 David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You
+# may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require_relative 'setup'
+
+require 'syncwrap/shell'
+
+class TestShell < MiniTest::Unit::TestCase
+  include TestOptions
+  include SyncWrap::Shell
+
+  ZFILE = File.expand_path( "../zfile", __FILE__ )
+
+  def test_command_lines_cleanup
+    cmd = command_lines_cleanup( [ "", "  a\nb", "\n c\n", "d m n \n \n" ] )
+    assert_equal( (%w[a b c] << "d m n").join( "\n" ), cmd )
+
+    cmd = <<-SH
+      if true; then
+
+        echo yep
+      else
+        echo huh
+      fi
+    SH
+
+    expected = [ "if true; then",
+                 "  echo yep",
+                 "else",
+                 "  echo huh",
+                 "fi" ].join( "\n" )
+
+    assert_equal( expected, command_lines_cleanup( cmd ) )
+    assert_equal( expected, command_lines_cleanup( expected ) )
+  end
+
+  def test_ssh_opts
+    args = ssh_args( 'test', 'true', ssh_options: {'IdentitiesOnly' => 'yes'} )
+    assert_equal( %w[ ssh -o IdentitiesOnly=yes test ], args[0..3] )
+  end
+
+  def test_capture_noop
+    exit_code, outputs = capture3( %w[bash -c true])
+    assert_equal( 0, exit_code )
+    assert_equal( [], outputs )
+  end
+
+  def test_capture_error
+    exit_code, outputs = capture3( %w[bash -v -c] << "exit 33" )
+    assert_equal( 33, exit_code )
+    assert_equal( [[:err, "exit 33\n"]], outputs, outputs )
+  end
+
+  def test_capture_output
+    exit_code, outputs = capture3( %w[bash -v -c] << "echo foo" )
+    assert_equal( 0, exit_code )
+    assert_equal( [ [:err, "echo foo\n"],
+                    [:out, "foo\n"] ],
+                  outputs.sort ) #order uncertain
+  end
+
+  def test_capture_big
+    exit_code, outputs = capture3( %w[bash -v -c] << "dd if=#{ZFILE} bs=1M" )
+    assert_equal( 0, exit_code )
+    assert_equal( IO.read( ZFILE ), collect_stream( :out, outputs ) )
+  end
+
+  def test_capture_output_interleaved
+    exit_code, outputs = capture3( sh_args( <<-'SH', sh_verbose: :v ))
+      echo foo
+      echo bar
+    SH
+    assert_equal( 0, exit_code )
+    assert_equal( "echo foo\necho bar\n",
+                  collect_stream( :err, outputs ) )
+    assert_equal( "foo\nbar\n",
+                  collect_stream( :out, outputs ) )
+  end
+
+  def test_capture_output_coalesce
+    cmd = sh_args( <<-'SH', sh_verbose: :v, coalesce: true )
+      echo foo
+      echo bar
+    SH
+    unmerged = []
+    exit_code, merged = capture3( cmd ) do |stream, chunk|
+      unmerged << [ stream, chunk ]
+    end
+    assert_equal( 0, exit_code )
+    assert_equal( [[:err, "echo foo\nfoo\necho bar\nbar\n"]],
+                  merged, merged )
+    post_merged = unmerged.map {|s,c| c}.inject( "", :+ )
+    assert_equal( merged[0][1], post_merged )
+  end
+
+  def test_capture_multi_error
+    # Timing dependent, one or two reads will be received. Regardless,
+    # capture3 should combine them to a single read as shown
+    11.times do
+      exit_code, outputs = capture3( %w[bash -v -c] << "echo foo >&2")
+      assert_equal( 0, exit_code )
+      assert_equal( [[:err, "echo foo >&2\nfoo\n"]],
+                    outputs, outputs )
+    end
+  end
+
+  def test_shell_special_chars
+    exit_code, outputs = capture3( sh_args( <<-'SH' ) )
+      var=33
+      echo \# "!var" "\"$var\"" "\$" "#"
+      echo \$ '!var' '"$var"' '$' '#'
+    SH
+    assert_equal( 0, exit_code )
+    assert_equal( [[:out, ( "# !var \"33\" $ #\n" +
+                            "$ !var \"$var\" $ #\n" )]],
+                  outputs, outputs )
+  end
+
+  def test_sudo
+    skip unless SAFE_SUDO
+    cmd = sudo_args( 'echo foo', user: :root )
+    exit_code, outputs = capture3( cmd )
+    assert_equal( 0, exit_code )
+    assert_equal( [[:out, "foo\n"]], outputs, outputs )
+  end
+
+  def test_ssh
+    skip unless SAFE_SSH
+    cmd = ssh_args( SAFE_SSH, 'echo foo', sh_verbose: :v )
+    exit_code, outputs = capture3( cmd )
+    assert_equal( 0, exit_code )
+    # Timing dependend order:
+    assert_equal( [ [:err, "echo foo\n"],
+                    [:out, "foo\n"] ],
+                  outputs.sort ) #order uncertain
+  end
+
+  def test_ssh_coalesce
+    skip unless SAFE_SSH
+    cmd = ssh_args( SAFE_SSH, <<-'SH', sh_verbose: :v, coalesce: true )
+      echo foo
+      echo bar
+    SH
+    unmerged = []
+    exit_code, merged = capture3( cmd ) do |stream, chunk|
+      unmerged << [ stream, chunk ]
+    end
+    assert_equal( 0, exit_code )
+    assert_equal( [[:err, "echo foo\nfoo\necho bar\nbar\n"]],
+                  merged, merged )
+    post_merged = unmerged.map {|s,c| c}.inject( "", :+ )
+    assert_equal( merged[0][1], post_merged )
+  end
+
+  def test_ssh_capture_big
+    skip unless SAFE_SSH
+    cmd = ssh_args( SAFE_SSH, "dd if=#{ZFILE} bs=1M" )
+    exit_code, outputs = capture3( cmd )
+    assert_equal( 0, exit_code )
+    assert_equal( IO.read( ZFILE ), collect_stream( :out, outputs ) )
+  end
+
+  def test_ssh_capture_big_2
+    skip unless SAFE_SSH
+    cmd = ssh_args( SAFE_SSH, <<-SH, coalesce:true )
+      for i in {1..1000}; do
+        echo "this is to stdout"
+        echo "this is to stderr" >&2
+      done
+    SH
+    exit_code, outputs = capture3( cmd )
+    assert_equal( 36_000, collect_stream( :err, outputs ).length )
+    assert_equal( 0, collect_stream( :out, outputs ).length )
+  end
+
+  def test_ssh_sudo
+    skip unless SAFE_SSH && SAFE_SSH_SUDO
+    cmd = ssh_args( SAFE_SSH, 'echo foo', sh_verbose: :v, user: :root )
+    exit_code, outputs = capture3( cmd )
+    assert_equal( 0, exit_code )
+    assert_equal( [ [:err, "echo foo\n"],
+                    [:out, "foo\n" ] ],
+                  outputs.sort ) #order uncertain
+  end
+
+  def test_ssh_sudo_coalesce
+    skip unless SAFE_SSH && SAFE_SSH_SUDO
+    cmd = ssh_args( SAFE_SSH, <<-'SH', sh_verbose: :v, coalesce: true, user: :root )
+      echo foo
+      echo bar
+    SH
+    unmerged = []
+    exit_code, merged = capture3( cmd ) do |stream, chunk|
+      unmerged << [ stream, chunk ]
+    end
+    assert_equal( 0, exit_code )
+    assert_equal( [[:err, "echo foo\nfoo\necho bar\nbar\n"]],
+                  merged, merged )
+    post_merged = unmerged.map {|s,c| c}.inject( "", :+ )
+    assert_equal( merged[0][1], post_merged )
+  end
+
+  def test_ssh_sudo_escape
+    skip unless SAFE_SSH && SAFE_SSH_SUDO
+    cmd = ssh_args( SAFE_SSH, <<-'SH', user: :root )
+      var=33
+      echo \# "!var" "\"$var\"" "\$" "#"
+      echo \$ '!var' '"$var"' '$' '#'
+    SH
+    exit_code, outputs = capture3( cmd )
+    assert_equal( 0, exit_code )
+    assert_equal( [[:out, ( "# !var \"33\" $ #\n" +
+                            "$ !var \"$var\" $ #\n" )]],
+                  outputs, outputs )
+  end
+
+end