train 1.5.11 → 1.6.3

data/test/unit/extras/command_wrapper_test.rb

@@ -1,110 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require 'helper'
-require 'train/transports/mock'
-require 'train/extras'
-require 'base64'
-
-describe 'linux command' do
-  let(:cls) { Train::Extras::LinuxCommand }
-  let(:cmd) { rand.to_s }
-  let(:backend) {
-    backend = Train::Transports::Mock.new.connection
-    backend.mock_os({ family: 'linux' })
-    backend
-  }
-
-  describe 'sudo wrapping' do
-    it 'wraps commands in sudo' do
-      lc = cls.new(backend, { sudo: true })
-      lc.run(cmd).must_equal "sudo #{cmd}"
-    end
-
-    it 'doesnt wrap commands in sudo if user == root' do
-      lc = cls.new(backend, { sudo: true, user: 'root' })
-      lc.run(cmd).must_equal cmd
-    end
-
-    it 'wraps commands in sudo with all options' do
-      opts = rand.to_s
-      lc = cls.new(backend, { sudo: true, sudo_options: opts })
-      lc.run(cmd).must_equal "sudo #{opts} #{cmd}"
-    end
-
-    it 'runs commands in sudo with password' do
-      pw = rand.to_s
-      lc = cls.new(backend, { sudo: true, sudo_password: pw })
-      bpw = Base64.strict_encode64(pw + "\n")
-      lc.run(cmd).must_equal "echo #{bpw} | base64 --decode | sudo -S #{cmd}"
-    end
-
-    it 'wraps commands in sudo_command instead of sudo' do
-      sudo_command = rand.to_s
-      lc = cls.new(backend, { sudo: true, sudo_command: sudo_command })
-      lc.run(cmd).must_equal "#{sudo_command} #{cmd}"
-    end
-
-    it 'wraps commands in sudo_command with all options' do
-      opts = rand.to_s
-      sudo_command = rand.to_s
-      lc = cls.new(backend, { sudo: true, sudo_command: sudo_command, sudo_options: opts })
-      lc.run(cmd).must_equal "#{sudo_command} #{opts} #{cmd}"
-    end
-
-    it 'runs commands in sudo_command with password' do
-      pw = rand.to_s
-      sudo_command = rand.to_s
-      lc = cls.new(backend, { sudo: true, sudo_command: sudo_command, sudo_password: pw })
-      bpw = Base64.strict_encode64(pw + "\n")
-      lc.run(cmd).must_equal "echo #{bpw} | base64 --decode | #{sudo_command} -S #{cmd}"
-    end
-  end
-
-  describe 'shell wrapping' do
-    it 'wraps commands in a default shell with login' do
-      lc = cls.new(backend, { shell: true, shell_options: '--login' })
-      bcmd = Base64.strict_encode64(cmd)
-      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL --login"
-    end
-
-    it 'wraps sudo commands in a default shell with login' do
-      lc = cls.new(backend, { sudo: true, shell: true, shell_options: '--login' })
-      bcmd = Base64.strict_encode64("sudo #{cmd}")
-      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL --login"
-    end
-
-    it 'wraps sudo commands and sudo passwords in a default shell with login' do
-      pw = rand.to_s
-      lc = cls.new(backend, { sudo: true, sudo_password: pw, shell: true, shell_options: '--login' })
-      bpw = Base64.strict_encode64(pw + "\n")
-      bcmd = Base64.strict_encode64("echo #{bpw} | base64 --decode | sudo -S #{cmd}")
-      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL --login"
-      p bcmd
-    end
-
-    it 'wraps commands in a default shell when shell is true' do
-      lc = cls.new(backend, { shell: true })
-      bcmd = Base64.strict_encode64(cmd)
-      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | $SHELL"
-    end
-
-    it 'doesnt wrap commands in a shell when shell is false' do
-      lc = cls.new(backend, { shell: false })
-      lc.run(cmd).must_equal cmd
-    end
-
-    it 'wraps commands in a `shell` instead of default shell' do
-      lc = cls.new(backend, { shell: true, shell_command: '/bin/bash' })
-      bcmd = Base64.strict_encode64(cmd)
-      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | /bin/bash"
-    end
-
-    it 'wraps commands in a default shell with login' do
-      lc = cls.new(backend, { shell: true, shell_command: '/bin/bash', shell_options: '--login' })
-      bcmd = Base64.strict_encode64(cmd)
-      lc.run(cmd).must_equal "echo #{bcmd} | base64 --decode | /bin/bash --login"
-    end
-  end
-end

data/test/unit/extras/stat_test.rb

@@ -1,210 +0,0 @@
-# encoding: utf-8
-require 'helper'
-require 'train/extras'
-require 'train/transports/mock'
-
-describe 'stat' do
-  let(:cls) { Train::Extras::Stat }
-
-  describe 'find_type' do
-    let (:random_mode) { (rand * 1000).to_i }
-
-    it 'detects :unknown types' do
-      cls.find_type(random_mode).must_equal :unknown
-    end
-
-    it 'detects sockets' do
-      cls.find_type(00140755).must_equal :socket
-    end
-
-    it 'detects symlinks' do
-      cls.find_type(00120755).must_equal :symlink
-    end
-
-    it 'detects files' do
-      cls.find_type(00100755).must_equal :file
-    end
-
-    it 'detects block devices' do
-      cls.find_type(00060755).must_equal :block_device
-    end
-
-    it 'detects directories' do
-      cls.find_type(00040755).must_equal :directory
-    end
-
-    it 'detects character devices' do
-      cls.find_type(00020755).must_equal :character_device
-    end
-
-    it 'detects pipes' do
-      cls.find_type(00010755).must_equal :pipe
-    end
-  end
-
-  describe 'linux stat' do
-    let(:backend) {
-      mock = Train::Transports::Mock.new(verbose: true).connection
-      mock.mock_os({ name: 'ubuntu', family: 'debian', release: '15.04', arch: 'x86_64' })
-      mock.commands = {
-        "stat /path 2>/dev/null --printf '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'" => mock.mock_command('', '', '', 0),
-        "stat /path-stat 2>/dev/null --printf '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'" => mock.mock_command('', "360\n43ff\nroot\n0\nrootz\n1\n1444520846\n1444522445\n?", '', 0),
-      }
-      mock
-    }
-
-    it 'ignores wrong stat results' do
-      cls.linux_stat('/path', backend, false).must_equal({})
-    end
-
-    it 'reads correct stat results' do
-      cls.linux_stat('/path-stat', backend, false).must_equal({
-        type: :directory,
-        mode: 01777,
-        owner: 'root',
-        uid: 0,
-        group: 'rootz',
-        gid: 1,
-        mtime: 1444522445,
-        size: 360,
-        selinux_label: nil,
-      })
-    end
-  end
-
-  describe 'esx stat' do
-    let(:backend) {
-      mock = Train::Transports::Mock.new(verbose: true).connection
-      mock.mock_os({ name: 'vmkernel', family: 'esx', release: '5' })
-      mock.commands = {
-        "stat /path 2>/dev/null -c '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'" => mock.mock_command('', '', '', 0),
-        "stat /path-stat 2>/dev/null -c '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'" => mock.mock_command('', "360\n43ff\nroot\n0\nrootz\n1\n1444520846\n1444522445\n?", '', 0),
-      }
-      mock
-    }
-
-    it 'ignores wrong stat results' do
-      cls.linux_stat('/path', backend, false).must_equal({})
-    end
-
-    it 'reads correct stat results' do
-      cls.linux_stat('/path-stat', backend, false).must_equal({
-        type: :directory,
-        mode: 01777,
-        owner: 'root',
-        uid: 0,
-        group: 'rootz',
-        gid: 1,
-        mtime: 1444522445,
-        size: 360,
-        selinux_label: nil,
-      })
-    end
-  end
-
-  describe 'alpine stat' do
-    let(:backend) {
-      mock = Train::Transports::Mock.new(verbose: true).connection
-      mock.mock_os({ name: 'alpine', family: 'alpine', release: nil })
-      mock.commands = {
-        "stat /path 2>/dev/null -c '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'" => mock.mock_command('', '', '', 0),
-        "stat /path-stat 2>/dev/null -c '%s\n%f\n%U\n%u\n%G\n%g\n%X\n%Y\n%C'" => mock.mock_command('', "360\n43ff\nroot\n0\nrootz\n1\n1444520846\n1444522445\n?", '', 0),
-      }
-      mock
-    }
-
-    it 'ignores wrong stat results' do
-      cls.linux_stat('/path', backend, false).must_equal({})
-    end
-
-    it 'reads correct stat results' do
-      cls.linux_stat('/path-stat', backend, false).must_equal({
-        type: :directory,
-        mode: 01777,
-        owner: 'root',
-        uid: 0,
-        group: 'rootz',
-        gid: 1,
-        mtime: 1444522445,
-        size: 360,
-        selinux_label: nil,
-      })
-    end
-  end
-
-  describe 'bsd stat' do
-    let(:backend) { Minitest::Mock.new }
-
-    it 'ignores failed stat results' do
-      res = Minitest::Mock.new
-      res.expect :stdout, '.....'
-      res.expect :exit_status, 1
-      backend.expect :run_command, res, [String]
-      cls.bsd_stat('/path', backend, false).must_equal({})
-    end
-
-    it 'ignores wrong stat results' do
-      res = Minitest::Mock.new
-      res.expect :stdout, ''
-      res.expect :exit_status, 0
-      backend.expect :run_command, res, [String]
-      cls.bsd_stat('/path', backend, false).must_equal({})
-    end
-
-    it 'reads correct stat results' do
-      res = Minitest::Mock.new
-      res.expect :stdout, "360\n41777\nroot\n0\nrootz\n1\n1444520846\n1444522445"
-      res.expect :exit_status, 0
-      backend.expect :run_command, res, [String]
-      cls.bsd_stat('/path', backend, false).must_equal({
-        type: :directory,
-        mode: 01777,
-        owner: 'root',
-        uid: 0,
-        group: 'rootz',
-        gid: 1,
-        mtime: 1444522445,
-        size: 360,
-        selinux_label: nil,
-      })
-    end
-  end
-
-  describe 'aix stat' do
-    let(:backend) { Minitest::Mock.new }
-
-    it 'ignores failed stat results' do
-      res = Minitest::Mock.new
-      res.expect :stdout, '.....'
-      res.expect :exit_status, 1
-      backend.expect :run_command, res, [String]
-      cls.aix_stat('/path', backend, false).must_equal({})
-    end
-
-    it 'ignores wrong stat results' do
-      res = Minitest::Mock.new
-      res.expect :stdout, ''
-      res.expect :exit_status, 0
-      backend.expect :run_command, res, [String]
-      cls.aix_stat('/path', backend, false).must_equal({})
-    end
-
-    it 'reads correct stat results' do
-      res = Minitest::Mock.new
-      res.expect :stdout, "41777\nroot\n0\nrootz\n1\n1444522445\n360\n"
-      res.expect :exit_status, 0
-      backend.expect :run_command, res, [String]
-      cls.aix_stat('/path', backend, false).must_equal({
-        type: :directory,
-        mode: 01777,
-        owner: 'root',
-        uid: 0,
-        group: 'rootz',
-        gid: 1,
-        mtime: 1444522445,
-        size: 360,
-        selinux_label: nil,
-      })
-    end
-  end
-end

data/test/unit/file/local/unix_test.rb

@@ -1,224 +0,0 @@
-require 'helper'
-require 'train/file/local/unix'
-require 'train/transports/mock'
-require 'train/transports/local'
-
-describe Train::File::Local::Unix do
-  let(:cls) { Train::File::Local::Unix }
-
-  let(:backend) {
-    backend = Train::Transports::Mock.new.connection
-    backend.mock_os({ family: 'linux' })
-    backend
-  }
-
-  it 'checks a mounted path' do
-    backend.mock_command("mount | grep -- ' on /mount/path '", rand.to_s)
-    cls.new(backend, '/mount/path').mounted?.must_equal true
-  end
-
-  describe 'file metadata' do
-    let(:transport) { Train::Transports::Local.new }
-    let(:connection) { transport.connection }
-
-    let(:stat) { Struct.new(:mode, :size, :mtime, :uid, :gid) }
-    let(:uid) { rand }
-    let(:gid) { rand }
-    let(:statres) { stat.new(00140755, rand, (rand*100).to_i, uid, gid) }
-
-    def meta_stub(method, param, &block)
-      pwres = Struct.new(:name)
-      Etc.stub :getpwuid, pwres.new('owner') do
-        Etc.stub :getgrgid, pwres.new('group') do
-          File.stub method, param do; yield; end
-        end
-      end
-    end
-
-    it 'recognizes type' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).stat[:type].must_equal :socket
-      end
-    end
-
-    it 'recognizes mode' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).stat[:mode].must_equal 00755
-      end
-    end
-
-    it 'recognizes mtime' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).stat[:mtime].must_equal statres.mtime
-      end
-    end
-
-    it 'recognizes size' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).stat[:size].must_equal statres.size
-      end
-    end
-
-    it 'recognizes uid' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).stat[:uid].must_equal uid
-      end
-    end
-
-    it 'recognizes gid' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).stat[:gid].must_equal gid
-      end
-    end
-
-    it 'recognizes owner' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).owner.must_equal 'owner'
-      end
-    end
-
-    it 'recognizes group' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).group.must_equal 'group'
-      end
-    end
-
-    it 'grouped_into' do
-      meta_stub :stat, statres do
-        connection.file(rand.to_s).grouped_into?('group').must_equal true
-      end
-    end
-
-    it 'recognizes selinux label' do
-      meta_stub :stat, statres do
-        label = rand.to_s
-        res = Train::Extras::CommandResult.new(label, nil, 0)
-        connection.stub :run_command, res do
-          connection.file(rand.to_s).selinux_label.must_equal label
-        end
-      end
-    end
-
-    it 'recognizes source selinux label' do
-      meta_stub :lstat, statres do
-        label = rand.to_s
-        res = Train::Extras::CommandResult.new(label, nil, 0)
-        connection.stub :run_command, res do
-          connection.file(rand.to_s).source.selinux_label.must_equal label
-        end
-      end
-    end
-  end
-
-  describe '#unix_mode_mask' do
-    let(:file_tester) do
-      Class.new(cls) do
-        define_method :type do
-          :file
-        end
-      end.new(nil, nil, false)
-    end
-
-    it 'check owner mode calculation' do
-      file_tester.unix_mode_mask('owner', 'x').must_equal 0100
-      file_tester.unix_mode_mask('owner', 'w').must_equal 0200
-      file_tester.unix_mode_mask('owner', 'r').must_equal 0400
-    end
-
-    it 'check group mode calculation' do
-      file_tester.unix_mode_mask('group', 'x').must_equal 0010
-      file_tester.unix_mode_mask('group', 'w').must_equal 0020
-      file_tester.unix_mode_mask('group', 'r').must_equal 0040
-    end
-
-    it 'check other mode calculation' do
-      file_tester.unix_mode_mask('other', 'x').must_equal 0001
-      file_tester.unix_mode_mask('other', 'w').must_equal 0002
-      file_tester.unix_mode_mask('other', 'r').must_equal 0004
-    end
-
-    it 'check all mode calculation' do
-      file_tester.unix_mode_mask('all', 'x').must_equal 0111
-      file_tester.unix_mode_mask('all', 'w').must_equal 0222
-      file_tester.unix_mode_mask('all', 'r').must_equal 0444
-    end
-  end
-
-  describe '#md5sum' do
-    let(:md5_checksum) { '57d4c6f9d15313fd5651317e588c035d' }
-
-    let(:ruby_md5_mock) do
-      checksum_mock = mock
-      checksum_mock.expects(:update).returns('')
-      checksum_mock.expects(:hexdigest).returns(md5_checksum)
-      checksum_mock
-    end
-
-    it 'defaults to a Ruby based checksum if other methods fail' do
-      backend.mock_command('md5sum /tmp/testfile', '', '', 1)
-      Digest::MD5.expects(:new).returns(ruby_md5_mock)
-      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
-    end
-
-    it 'calculates the correct md5sum on the `linux` platform family' do
-      output = "#{md5_checksum} /tmp/testfile"
-      backend.mock_command('md5sum /tmp/testfile', output)
-      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
-    end
-
-    it 'calculates the correct md5sum on the `darwin` platform family' do
-      output = "#{md5_checksum} /tmp/testfile"
-      backend.mock_os(family: 'darwin')
-      backend.mock_command('md5 -r /tmp/testfile', output)
-      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
-    end
-
-    it 'calculates the correct md5sum on the `solaris` platform family' do
-      # The `digest` command doesn't output the filename by default
-      output = "#{md5_checksum}"
-      backend.mock_os(family: 'solaris')
-      backend.mock_command('digest -a md5 /tmp/testfile', output)
-      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
-    end
-  end
-
-  describe '#sha256sum' do
-    let(:sha256_checksum) {
-      '491260aaa6638d4a64c714a17828c3d82bad6ca600c9149b3b3350e91bcd283d'
-    }
-
-    let(:ruby_sha256_mock) do
-      checksum_mock = mock
-      checksum_mock.expects(:update).returns('')
-      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
-      checksum_mock
-    end
-
-    it 'defaults to a Ruby based checksum if other methods fail' do
-      backend.mock_command('sha256sum /tmp/testfile', '', '', 1)
-      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
-      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
-    end
-
-    it 'calculates the correct sha256sum on the `linux` platform family' do
-      output = "#{sha256_checksum} /tmp/testfile"
-      backend.mock_command('sha256sum /tmp/testfile', output)
-      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
-    end
-
-    it 'calculates the correct sha256sum on the `darwin` platform family' do
-      output = "#{sha256_checksum} /tmp/testfile"
-      backend.mock_os(family: 'darwin')
-      backend.mock_command('shasum -a 256 /tmp/testfile', output)
-      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
-    end
-
-    it 'calculates the correct sha256sum on the `solaris` platform family' do
-      # The `digest` command doesn't output the filename by default
-      output = "#{sha256_checksum}"
-      backend.mock_os(family: 'solaris')
-      backend.mock_command('digest -a sha256 /tmp/testfile', output)
-      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
-    end
-  end
-end

data/test/unit/file/local/windows_test.rb

@@ -1,101 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'train/transports/mock'
-require 'train/file/local/windows'
-
-describe 'file common' do
-  let(:cls) { Train::File::Local::Windows }
-  let(:backend) {
-    backend = Train::Transports::Mock.new.connection
-    backend.mock_os({ family: 'windows' })
-    backend
-  }
-
-  it 'check escaping of invalid chars in path' do
-    wf = cls.new(nil, nil)
-    wf.sanitize_filename('c:/test') .must_equal 'c:/test'
-    wf.sanitize_filename('c:/test directory') .must_equal 'c:/test directory'
-    %w{ < > " * ?}.each do |char|
-      wf.sanitize_filename("c:/test#{char}directory") .must_equal 'c:/testdirectory'
-    end
-  end
-
-  it 'returns file version' do
-    out = rand.to_s
-    backend.mock_command('[System.Diagnostics.FileVersionInfo]::GetVersionInfo("path").FileVersion', out)
-    cls.new(backend, 'path').file_version.must_equal out
-  end
-
-  it 'returns product version' do
-    out = rand.to_s
-    backend.mock_command('[System.Diagnostics.FileVersionInfo]::GetVersionInfo("path").FileVersion', out)
-    cls.new(backend, 'path').file_version.must_equal out
-  end
-
-  it 'returns owner of file' do
-    out = rand.to_s
-    backend.mock_command('Get-Acl "path" | select -expand Owner', out)
-    cls.new(backend, 'path').owner.must_equal out
-  end
-
-  describe '#md5sum' do
-    let(:md5_checksum) { '4ce0c733cdcf1d2f78532bbd9ce3441d' }
-    let(:filepath) { 'C:\Windows\explorer.exe' }
-
-    let(:ruby_md5_mock) do
-      checksum_mock = mock
-      checksum_mock.expects(:update).returns('')
-      checksum_mock.expects(:hexdigest).returns(md5_checksum)
-      checksum_mock
-    end
-
-    it 'defaults to a Ruby based checksum if other methods fail' do
-      backend.mock_command("CertUtil -hashfile #{filepath} MD5", '', '', 1)
-      Digest::MD5.expects(:new).returns(ruby_md5_mock)
-      cls.new(backend, '/tmp/testfile').md5sum.must_equal md5_checksum
-    end
-
-    it 'calculates the correct md5sum on the `windows` platform family' do
-      output = <<-EOC
-        MD5 hash of file C:\\Windows\\explorer.exe:\r
-        4c e0 c7 33 cd cf 1d 2f 78 53 2b bd 9c e3 44 1d\r
-        CertUtil: -hashfile command completed successfully.\r
-      EOC
-
-      backend.mock_command("CertUtil -hashfile #{filepath} MD5", output)
-      cls.new(backend, filepath).md5sum.must_equal md5_checksum
-    end
-  end
-
-  describe '#sha256sum' do
-    let(:sha256_checksum) {
-      '85270240a5fd51934f0627c92b2282749d071fdc9ac351b81039ced5b10f798b'
-    }
-    let(:filepath) { 'C:\Windows\explorer.exe' }
-
-    let(:ruby_sha256_mock) do
-      checksum_mock = mock
-      checksum_mock.expects(:update).returns('')
-      checksum_mock.expects(:hexdigest).returns(sha256_checksum)
-      checksum_mock
-    end
-
-    it 'defaults to a Ruby based checksum if other methods fail' do
-      backend.mock_command('CertUtil -hashfile #{filepath} SHA256', '', '', 1)
-      Digest::SHA256.expects(:new).returns(ruby_sha256_mock)
-      cls.new(backend, '/tmp/testfile').sha256sum.must_equal sha256_checksum
-    end
-
-    it 'calculates the correct sha256sum on the `windows` platform family' do
-      output = <<-EOC
-        SHA256 hash of file C:\\Windows\\explorer.exe:\r
-        85 27 02 40 a5 fd 51 93 4f 06 27 c9 2b 22 82 74 9d 07 1f dc 9a c3 51 b8 10 39 ce d5 b1 0f 79 8b\r
-        CertUtil: -hashfile command completed successfully.\r
-      EOC
-
-      backend.mock_command("CertUtil -hashfile #{filepath} SHA256", output)
-      cls.new(backend, filepath).sha256sum.must_equal sha256_checksum
-    end
-  end
-end