train 0.12.1

data/test/integration/tests/path_missing_test.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+describe 'file interface' do
+  let(:backend) { get_backend.call }
+
+  describe 'a path that doesnt exist' do
+    let(:file) {
+      backend.file('/do_not_create_this_path_please_or_my_tests_will_fail')
+    }
+
+    it 'does not exist' do
+      file.exist?.must_equal(false)
+    end
+
+    it 'is not a file' do
+      file.file?.must_equal(false)
+    end
+
+    it 'has type nil' do
+      file.type.must_be_nil
+    end
+
+    it 'has no content' do
+      file.content.must_be_nil
+    end
+
+    it 'has no owner' do
+      file.owner.must_be_nil
+    end
+
+    it 'has no group' do
+      file.group.must_be_nil
+    end
+
+    it 'has mode nil' do
+      file.mode.must_be_nil
+    end
+
+    it 'checks mode? nil' do
+      file.mode?(nil).must_equal(true)
+    end
+
+    it 'has no link_path' do
+      file.link_path.must_be_nil
+    end
+
+    it 'has an md5sum' do
+      file.md5sum.must_be_nil
+    end
+
+    it 'has an sha256sum' do
+      file.sha256sum.must_be_nil
+    end
+
+    it 'has a modified time' do
+      file.mtime.must_be_nil
+    end
+
+    it 'has inode size' do
+      # Must be around 11 Bytes, +- 4
+      file.size.must_be_nil
+    end
+
+    it 'has no selinux_label' do
+      file.selinux_label.must_be_nil
+    end
+
+    it 'has no product_version' do
+      file.product_version.must_be_nil
+    end
+
+    it 'has no file_version' do
+      file.file_version.must_be_nil
+    end
+
+  end
+end

data/test/integration/tests/path_pipe_test.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+describe 'file interface' do
+  let(:backend) { get_backend.call }
+
+  describe 'pipe / fifo' do
+    let(:file) { backend.file('/tmp/pipe') }
+
+    it 'exists' do
+      file.exist?.must_equal(true)
+    end
+
+    it 'is a pipe' do
+      file.pipe?.must_equal(true)
+    end
+
+    it 'has type :pipe' do
+      file.type.must_equal(:pipe)
+    end
+
+    # # TODO add back content
+    # it 'has no content' do
+    #   file.content.must_be_nil
+    # end
+
+    it 'has owner name root' do
+      file.owner.must_equal('root')
+    end
+
+    it 'has group name' do
+      file.group.must_equal(Test.root_group(backend.os))
+    end
+
+    it 'has mode 0644' do
+      file.mode.must_equal(00644)
+    end
+
+    it 'checks mode? 0644' do
+      file.mode?(00644).must_equal(true)
+    end
+
+    it 'has no link_path' do
+      file.link_path.must_be_nil
+    end
+
+    # # TODO add back content
+    # it 'has no md5sum' do
+    #   file.md5sum.must_be_nil
+    # end
+    #
+    # # TODO add back content
+    # it 'has no sha256sum' do
+    #   file.sha256sum.must_be_nil
+    # end
+
+    it 'has a modified time' do
+      file.mtime.must_be_close_to(Time.now.to_i - Test.mtime/2, Test.mtime)
+    end
+
+    it 'has inode size of 0' do
+      file.size.must_equal(0)
+    end
+
+    it 'has selinux label handling' do
+      res = Test.selinux_label(backend, file.path)
+      file.selinux_label.must_equal(res)
+    end
+
+
+    it 'has no product_version' do
+      file.product_version.must_equal(nil)
+    end
+
+    it 'has no file_version' do
+      file.file_version.must_equal(nil)
+    end
+  end
+end

data/test/integration/tests/path_symlink_test.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+describe 'file interface' do
+  let(:backend) { get_backend.call }
+
+  describe 'symlink file' do
+    let(:file) { backend.file('/tmp/symlink') }
+
+    it 'exists' do
+      file.exist?.must_equal(true)
+    end
+
+    it 'is a symlink' do
+      file.symlink?.must_equal(true)
+    end
+
+    it 'is pointing to a file' do
+      file.file?.must_equal(true)
+    end
+
+    it 'is not pointing to a folder' do
+      file.directory?.must_equal(false)
+    end
+
+    it 'has type :file' do
+      file.type.must_equal(:file)
+    end
+
+    it 'has content' do
+      file.content.must_equal('hello world')
+    end
+
+    it 'has owner name root' do
+      file.owner.must_equal('root')
+    end
+
+    it 'has uid 0' do
+      file.uid.must_equal(0)
+    end
+
+    it 'has group name' do
+      file.group.must_equal(Test.root_group(backend.os))
+    end
+
+    it 'has gid 0' do
+      file.gid.must_equal(0)
+    end
+
+    it 'has mode 0777' do
+      file.source.mode.must_equal(00777)
+    end
+
+    it 'has mode 0765' do
+      file.mode.must_equal(00765)
+    end
+
+    it 'checks mode? 0765' do
+      file.mode?(00765).must_equal(true)
+    end
+
+    it 'has link_path' do
+      file.link_path.must_equal('/tmp/file')
+    end
+
+    it 'has an md5sum' do
+      file.md5sum.must_equal('5eb63bbbe01eeed093cb22bb8f5acdc3')
+    end
+
+    it 'has an sha256sum' do
+      file.sha256sum.must_equal('b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9')
+    end
+
+    it 'has a modified time' do
+      file.mtime.must_be_close_to(Time.now.to_i - Test.mtime/2, Test.mtime)
+    end
+
+    it 'has size' do
+      # Must be around 11 Bytes, +- 4
+      file.size.must_be_close_to(11, 4)
+    end
+
+    it 'has selinux label handling' do
+      res = Test.selinux_label(backend, file.path)
+      file.selinux_label.must_equal(res)
+    end
+
+    it 'has no product_version' do
+      file.product_version.must_equal(nil)
+    end
+
+    it 'has no file_version' do
+      file.file_version.must_equal(nil)
+    end
+  end
+end

data/test/integration/tests/run_command_test.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+describe 'run_command' do
+  let(:backend) { get_backend.call() }
+
+  it 'can echo commands' do
+    res = backend.run_command('echo hello world')
+    res.stdout.must_equal("hello world\n")
+    res.stderr.must_equal('')
+    res.exit_status.must_equal(0)
+  end
+
+  it 'can echo commands to stderr' do
+    # TODO: Specinfra often fails on this test.
+    # Fix and re-enable it.
+    res = backend.run_command('>&2 echo hello world')
+    res.stdout.must_equal('')
+    res.stderr.must_equal("hello world\n")
+    res.exit_status.must_equal(0)
+  end
+
+  it 'prints a correct exit status' do
+    res = backend.run_command('exit 123')
+    res.stdout.must_equal('')
+    res.stderr.must_equal('')
+    res.exit_status.must_equal(123)
+  end
+end

data/test/unit/extras/command_wrapper_test.rb

@@ -0,0 +1,78 @@
+# 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
+  }
+
+  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 -d | 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 -d | #{sudo_command} -S #{cmd}"
+  end
+end
+
+describe 'powershell command' do
+  let(:cls) { Train::Extras::PowerShellCommand }
+  let(:cmd) { rand.to_s }
+  let(:backend) {
+    backend = Train::Transports::Mock.new.connection
+    backend.mock_os({ family: 'windows' })
+    backend
+  }
+
+  it 'wraps commands in powershell' do
+    lc = cls.new(backend, {})
+    tmp =
+    lc.run(cmd).must_equal "powershell -encodedCommand #{WinRM::PowershellScript.new('$ProgressPreference=\'SilentlyContinue\';' + cmd).encoded}"
+  end
+end

data/test/unit/extras/file_common_test.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+require 'helper'
+require 'securerandom'
+require 'train/extras/file_common'
+
+describe 'file common' do
+  let(:cls) { Train::Extras::FileCommon }
+  let(:new_cls) { cls.new(nil, nil, false) }
+
+  def mockup(stubs)
+    Class.new(cls) do
+      stubs.each do |k,v|
+        define_method k.to_sym do
+          v
+        end
+      end
+    end.new(nil, nil, false)
+  end
+
+  it 'has the default type of unknown' do
+    new_cls.type.must_equal :unknown
+  end
+
+  it 'calculates md5sum from content' do
+    content = 'hello world'
+    new_cls.stub :content, content do |i|
+      i.md5sum.must_equal '5eb63bbbe01eeed093cb22bb8f5acdc3'
+    end
+  end
+
+  it 'sets md5sum of nil content to nil' do
+    new_cls.stub :content, nil do |i|
+      i.md5sum.must_be_nil
+    end
+  end
+
+  it 'calculates md5sum from content' do
+    content = 'hello world'
+    new_cls.stub :content, content do |i|
+      i.sha256sum.must_equal 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9'
+    end
+  end
+
+  it 'sets sha256sum of nil content to nil' do
+    new_cls.stub :content, nil do |i|
+      i.sha256sum.must_be_nil
+    end
+  end
+
+  describe 'type' do
+    it 'recognized type == file' do
+      fc = mockup(type: :file)
+      fc.file?.must_equal true
+    end
+
+    it 'recognized type == block_device' do
+      fc = mockup(type: :block_device)
+      fc.block_device?.must_equal true
+    end
+
+    it 'recognized type == character_device' do
+      fc = mockup(type: :character_device)
+      fc.character_device?.must_equal true
+    end
+
+    it 'recognized type == socket' do
+      fc = mockup(type: :socket)
+      fc.socket?.must_equal true
+    end
+
+    it 'recognized type == directory' do
+      fc = mockup(type: :directory)
+      fc.directory?.must_equal true
+    end
+
+    it 'recognized type == pipe' do
+      fc = mockup(type: :pipe)
+      fc.pipe?.must_equal true
+    end
+
+    it 'recognized type == symlink' do
+      fc = mockup(type: :symlink)
+      fc.symlink?.must_equal true
+    end
+  end
+
+  describe 'version' do
+    it 'recognized wrong version' do
+      fc = mockup(product_version: rand, file_version: rand)
+      fc.version?(rand).must_equal false
+    end
+
+    it 'recognized product_version' do
+      x = rand
+      fc = mockup(product_version: x, file_version: rand)
+      fc.version?(x).must_equal true
+    end
+
+    it 'recognized file_version' do
+      x = rand
+      fc = mockup(product_version: rand, file_version: x)
+      fc.version?(x).must_equal true
+    end
+  end
+
+  describe 'unix_mode_mask' do
+
+    let(:fc) { mockup(type: :file) }
+
+    it 'check owner mode calculation' do
+      fc.unix_mode_mask('owner', 'x').must_equal 0100
+      fc.unix_mode_mask('owner', 'w').must_equal 0200
+      fc.unix_mode_mask('owner', 'r').must_equal 0400
+    end
+
+    it 'check group mode calculation' do
+      fc.unix_mode_mask('group', 'x').must_equal 0010
+      fc.unix_mode_mask('group', 'w').must_equal 0020
+      fc.unix_mode_mask('group', 'r').must_equal 0040
+    end
+
+    it 'check other mode calculation' do
+      fc.unix_mode_mask('other', 'x').must_equal 0001
+      fc.unix_mode_mask('other', 'w').must_equal 0002
+      fc.unix_mode_mask('other', 'r').must_equal 0004
+    end
+
+    it 'check all mode calculation' do
+      fc.unix_mode_mask('all', 'x').must_equal 0111
+      fc.unix_mode_mask('all', 'w').must_equal 0222
+      fc.unix_mode_mask('all', 'r').must_equal 0444
+    end
+  end
+
+  describe 'basename helper' do
+    def fc(path)
+      mockup(type: :file, path: path)
+    end
+
+    it 'works with an empty path' do
+      fc('').basename.must_equal ''
+    end
+
+    it 'separates a simple path (defaults to unix mode)' do
+      fc('/dir/file').basename.must_equal 'file'
+    end
+
+    it 'separates a simple path (Unix mode)' do
+      fc('/dir/file').basename(nil, '/').must_equal 'file'
+    end
+
+    it 'separates a simple path (Windows mode)' do
+      fc('C:\dir\file').basename(nil, '\\').must_equal 'file'
+    end
+
+    it 'identifies a folder name (Unix mode)' do
+      fc('/dir/file/').basename(nil, '/').must_equal 'file'
+    end
+
+    it 'identifies a folder name (Windows mode)' do
+      fc('C:\dir\file\\').basename(nil, '\\').must_equal 'file'
+    end
+
+    it 'ignores tailing separators (Unix mode)' do
+      fc('/dir/file///').basename(nil, '/').must_equal 'file'
+    end
+
+    it 'ignores tailing separators (Windows mode)' do
+      fc('C:\dir\file\\\\\\').basename(nil, '\\').must_equal 'file'
+    end
+
+    it 'doesnt work with backward slashes (Unix mode)' do
+      fc('C:\dir\file').basename(nil, '/').must_equal 'C:\\dir\file'
+    end
+
+    it 'doesnt work with forward slashes (Windows mode)' do
+      fc('/dir/file').basename(nil, '\\').must_equal '/dir/file'
+    end
+  end
+end