train 1.5.11 → 1.6.3

data/test/unit/file/remote_test.rb

@@ -1,62 +0,0 @@
-require 'helper'
-require 'train/file/remote'
-
-describe Train::File::Remote do
-  let(:cls) { Train::File::Remote }  
-
-  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  
-
-  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  

data/test/unit/file_test.rb

@@ -1,129 +0,0 @@
-require 'helper'
-
-describe Train::File do
-  let(:cls) { Train::File }
-  let(:new_cls) { cls.new(nil, '/temp/file', 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 'throws Not implemented error for exist?' do
-    # proc { Train.validate_backend({ host: rand }) }.must_raise Train::UserError
-    proc { new_cls.exist?}.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for mode' do
-    proc { new_cls.mode }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for owner' do
-    proc { new_cls.owner }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for group' do
-    proc { new_cls.group }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for uid' do
-    proc { new_cls.uid }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for gid' do
-    proc { new_cls.gid }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for content' do
-    proc { new_cls.content }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for mtime' do
-    proc { new_cls.mtime }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for size' do
-    proc { new_cls.size }.must_raise NotImplementedError
-  end
-
-  it 'throws Not implemented error for selinux_label' do
-    proc { new_cls.selinux_label }.must_raise NotImplementedError
-  end
-
-  it 'return path of file' do
-    new_cls.path.must_equal('/temp/file')
-  end
-
-  it 'set product_version to nil' do
-    new_cls.product_version.must_be_nil
-  end
-
-  it 'set product_version to nil' do
-    new_cls.file_version.must_be_nil
-  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
-end

data/test/unit/helper.rb

@@ -1,7 +0,0 @@
-# encoding: utf-8
-
-require 'minitest/autorun'
-require 'minitest/spec'
-require 'mocha/setup'
-
-require 'train'

data/test/unit/platforms/detect/os_common_test.rb

@@ -1,85 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-
-class OsDetectLinuxTester
-  attr_reader :platform
-  include Train::Platforms::Detect::Helpers::OSCommon
-
-  def initialize
-    @platform = {}
-  end
-end
-
-describe 'os_common' do
-  let(:detector) { OsDetectLinuxTester.new }
-
-  describe 'winrm? check' do
-    it 'return winrm? true' do
-      require 'train/transports/winrm'
-      be = Train::Transports::WinRM::Connection.new(nil)
-      detector.instance_variable_set(:@backend, be)
-      detector.winrm?.must_equal(true)
-    end
-
-    it 'return winrm? false' do
-      be = mock('Backend')
-      detector.instance_variable_set(:@backend, be)
-      detector.winrm?.must_equal(false)
-    end
-  end
-
-  describe 'unix file contents' do
-    it 'return new file contents' do
-      be = mock('Backend')
-      output = mock('Output', exit_status: 0)
-      output.expects(:stdout).returns('test')
-      be.stubs(:run_command).with('test -f /etc/fstab && cat /etc/fstab').returns(output)
-      detector.instance_variable_set(:@backend, be)
-      detector.instance_variable_set(:@files, {})
-      detector.unix_file_contents('/etc/fstab').must_equal('test')
-    end
-
-    it 'return new file contents cached' do
-      be = mock('Backend')
-      detector.instance_variable_set(:@backend, be)
-      detector.instance_variable_set(:@files, { '/etc/profile' => 'test' })
-      detector.unix_file_contents('/etc/profile').must_equal('test')
-    end
-  end
-
-  describe 'unix file exist?' do
-    it 'file does exist' do
-      be = mock('Backend')
-      be.stubs(:run_command).with('test -f /etc/test').returns(mock('Output', exit_status: 0))
-      detector.instance_variable_set(:@backend, be)
-      detector.unix_file_exist?('/etc/test').must_equal(true)
-    end
-  end
-
-  describe '#detect_linux_arch' do
-    it 'uname m call' do
-      be = mock('Backend')
-      be.stubs(:run_command).with('uname -m').returns(mock('Output', stdout: "x86_64\n"))
-      detector.instance_variable_set(:@backend, be)
-      detector.instance_variable_set(:@uname, {})
-      detector.unix_uname_m.must_equal('x86_64')
-    end
-
-    it 'uname s call' do
-      be = mock('Backend')
-      be.stubs(:run_command).with('uname -s').returns(mock('Output', stdout: "linux"))
-      detector.instance_variable_set(:@backend, be)
-      detector.instance_variable_set(:@uname, {})
-      detector.unix_uname_s.must_equal('linux')
-    end
-
-    it 'uname r call' do
-      be = mock('Backend')
-      be.stubs(:run_command).with('uname -r').returns(mock('Output', stdout: "17.0.0\n"))
-      detector.instance_variable_set(:@backend, be)
-      detector.instance_variable_set(:@uname, {})
-      detector.unix_uname_r.must_equal('17.0.0')
-    end
-  end
-end

data/test/unit/platforms/detect/os_linux_test.rb

@@ -1,132 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'train/transports/mock'
-
-class OsDetectLinuxTester
-  include Train::Platforms::Detect::Helpers::OSCommon
-end
-
-describe 'os_linux' do
-  let(:detector) { OsDetectLinuxTester.new }
-
-  describe 'redhatish_platform cleaner' do
-    it 'normal redhat' do
-      detector.redhatish_platform('Red Hattter').must_equal('redhat')
-    end
-
-    it 'custom redhat' do
-      detector.redhatish_platform('Centos Pro 11').must_equal('centos')
-    end
-  end
-
-  describe 'redhatish_version cleaner' do
-    it 'normal rawhide' do
-      detector.redhatish_version('18 (Rawhide) Pro').must_equal('18 (rawhide)')
-    end
-
-    it 'normal linux' do
-      detector.redhatish_version('derived from Ubuntu Linux 11').must_equal('11')
-    end
-
-    it 'amazon linux 2 new release naming schema' do
-      detector.redhatish_version('Amazon Linux release 2 (Karoo)').must_equal('2')
-    end
-
-    it 'amazon linux 2 old release naming schema' do
-      detector.redhatish_version('Amazon Linux 2').must_equal('2')
-    end
-  end
-
-  describe 'lsb parse' do
-    it 'lsb config' do
-      lsb = "DISTRIB_ID=Ubuntu\nDISTRIB_RELEASE=14.06\nDISTRIB_CODENAME=xenial"
-      expect = { :id=>'Ubuntu', :release=>'14.06', :codename=>'xenial' }
-      detector.lsb_config(lsb).must_equal(expect)
-    end
-
-    it 'lsb releasel' do
-      lsb = "Distributor ID: Ubuntu\nRelease: 14.06\nCodename: xenial"
-      expect = { :id=>'Ubuntu', :release=>'14.06', :codename=>'xenial' }
-      detector.lsb_release(lsb).must_equal(expect)
-    end
-  end
-
-  describe '#linux_os_release' do
-    describe 'when no os-release data is available' do
-      it 'returns nil' do
-        detector.expects(:unix_file_contents).with('/etc/os-release').returns(nil)
-        detector.linux_os_release.must_be_nil
-      end
-    end
-  end
-
-  describe 'when os-release data exists with no CISCO_RELEASE_INFO' do
-    let(:os_release) { { 'KEY1' => 'VALUE1' } }
-
-    it 'returns a correct hash' do
-      detector.expects(:unix_file_contents).with('/etc/os-release').returns('os-release data')
-      detector.expects(:parse_os_release_info).with('os-release data').returns(os_release)
-      detector.linux_os_release['KEY1'].must_equal('VALUE1')
-    end
-  end
-
-  describe 'when os-release data exists with CISCO_RELEASE_INFO' do
-    let(:os_release)    { { 'KEY1' => 'VALUE1', 'CISCO_RELEASE_INFO' => 'cisco_file' } }
-    let(:cisco_release) { { 'KEY1' => 'NEWVALUE1', 'KEY2' => 'VALUE2' } }
-
-    it 'returns a correct hash' do
-      detector.expects(:unix_file_contents).with('/etc/os-release').returns('os-release data')
-      detector.expects(:unix_file_contents).with('cisco_file').returns('cisco data')
-      detector.expects(:parse_os_release_info).with('os-release data').returns(os_release)
-      detector.expects(:parse_os_release_info).with('cisco data').returns(cisco_release)
-
-      os_info = detector.linux_os_release
-      os_info['KEY1'].must_equal('NEWVALUE1')
-      os_info['KEY2'].must_equal('VALUE2')
-    end
-  end
-
-  describe '#parse_os_release_info' do
-    describe 'when nil is supplied' do
-      it 'returns an empty hash' do
-        detector.parse_os_release_info(nil).must_equal({})
-      end
-    end
-
-    describe 'when unexpectedly-formatted data is supplied' do
-      let(:data) do
-        <<-EOL
-blah blah
-no good data here
-        EOL
-      end
-
-      it 'returns an empty hash' do
-        detector.parse_os_release_info(nil).must_equal({})
-      end
-    end
-
-    describe 'when properly-formatted data is supplied' do
-      let(:data) do
-        <<-EOL
-KEY1=value1
-KEY2=
-KEY3=value3
-KEY4="value4 with spaces"
-KEY5="value5 with a = sign"
-        EOL
-      end
-
-      it 'parses the data correctly' do
-        parsed_data = detector.parse_os_release_info(data)
-
-        parsed_data['KEY1'].must_equal('value1')
-        parsed_data.key?('KEY2').must_equal(false)
-        parsed_data['KEY3'].must_equal('value3')
-        parsed_data['KEY4'].must_equal('value4 with spaces')
-        parsed_data['KEY5'].must_equal('value5 with a = sign')
-      end
-    end
-  end
-end

data/test/unit/platforms/detect/os_windows_test.rb

@@ -1,107 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'train/transports/mock'
-
-class OsDetectWindowsTester
-  attr_reader :platform, :backend
-  include Train::Platforms::Detect::Helpers::Windows
-
-  def initialize
-    @platform = {}
-    @backend = Train::Transports::Mock.new.connection
-    @backend.mock_os({ family: 'windows' })
-  end
-end
-
-describe 'os_detect_windows' do
-  describe 'windows 2012' do
-    let(:detector) {
-      detector = OsDetectWindowsTester.new
-      detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 6.3.9600]\r\n", '', 0)
-      detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=9600\r\r\nCaption=Microsoft Windows Server 2012 R2 Standard\r\r\nOSArchitecture=64-bit\r\r\nVersion=6.3.9600\r\r\n" , '', 0)
-      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=9\r\r\n" , '', 0)
-      detector
-    }
-
-    it 'sets the correct family/release for windows' do
-      detector.detect_windows
-      detector.platform[:family].must_equal('windows')
-      detector.platform[:name].must_equal('Windows Server 2012 R2 Standard')
-      detector.platform[:arch].must_equal('x86_64')
-      detector.platform[:release].must_equal('6.3.9600')
-    end
-  end
-
-  describe 'windows 2008' do
-    let(:detector) {
-      detector = OsDetectWindowsTester.new
-      detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 6.1.7601]\r\n", '', 0)
-      detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=7601\r\r\nCaption=Microsoft Windows Server 2008 R2 Standard \r\r\nOSArchitecture=64-bit\r\r\nVersion=6.1.7601\r\r\n" , '', 0)
-      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=9\r\r\n" , '', 0)
-      detector
-    }
-
-    it 'sets the correct family/release for windows' do
-      detector.detect_windows
-      detector.platform[:family].must_equal('windows')
-      detector.platform[:name].must_equal('Windows Server 2008 R2 Standard')
-      detector.platform[:arch].must_equal('x86_64')
-      detector.platform[:release].must_equal('6.1.7601')
-    end
-  end
-
-  describe 'windows 7' do
-    let(:detector) {
-      detector = OsDetectWindowsTester.new
-      detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 6.1.7601]\r\n", '', 0)
-      detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=7601\r\r\nCaption=Microsoft Windows 7 Enterprise \r\r\nOSArchitecture=32-bit\r\r\nVersion=6.1.7601\r\r\n\r\r\n" , '', 0)
-      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=0\r\r\n" , '', 0)
-      detector
-    }
-
-    it 'sets the correct family/release for windows' do
-      detector.detect_windows
-      detector.platform[:family].must_equal('windows')
-      detector.platform[:name].must_equal('Windows 7 Enterprise')
-      detector.platform[:arch].must_equal('i386')
-      detector.platform[:release].must_equal('6.1.7601')
-    end
-  end
-
-  describe 'windows 10' do
-    let(:detector) {
-      detector = OsDetectWindowsTester.new
-      detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 10.0.10240]\r\n", '', 0)
-      detector.backend.mock_command('wmic os get * /format:list',"\r\r\nBuildNumber=10240\r\r\nCaption=Microsoft Windows 10 Pro\r\r\nOSArchitecture=64-bit\r\r\nVersion=10.0.10240\r\r\n\r\r\n" , '', 0)
-      detector.backend.mock_command('wmic cpu get architecture /format:list',"\r\r\nArchitecture=9\r\r\n" , '', 0)
-      detector
-    }
-
-    it 'sets the correct family/release for windows' do
-      detector.detect_windows
-      detector.platform[:family].must_equal('windows')
-      detector.platform[:name].must_equal('Windows 10 Pro')
-      detector.platform[:arch].must_equal('x86_64')
-      detector.platform[:release].must_equal('10.0.10240')
-    end
-  end
-
-  describe 'windows 98' do
-    let(:detector) {
-      detector = OsDetectWindowsTester.new
-      detector.backend.mock_command('cmd /c ver', "\r\nMicrosoft Windows [Version 4.10.1998]\r\n", '', 0)
-      detector.backend.mock_command('wmic os get * /format:list', nil, '', 1)
-      detector.backend.mock_command('wmic cpu get architecture /format:list', nil, '', 1)
-      detector
-    }
-
-    it 'fallback to version number if wmic is not available' do
-      detector.detect_windows
-      detector.platform[:family].must_equal('windows')
-      detector.platform[:name].must_equal('Windows 4.10.1998')
-      detector.platform[:arch].must_be_nil
-      detector.platform[:release].must_equal('4.10.1998')
-    end
-  end
-end

data/test/unit/platforms/detect/scanner_test.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'train/platforms/detect/scanner'
-require 'train/transports/mock'
-
-describe 'scanner' do
-  let(:backend) { Train::Transports::Mock::Connection.new }
-  let(:scanner) { Train::Platforms::Detect::Scanner.new(backend) }
-
-  describe 'scan family children' do
-    it 'return child' do
-      family = Train::Platforms.family('linux')
-      scanner.scan_family_children(family).name.must_equal('linux')
-      scanner.instance_variable_get(:@family_hierarchy).must_equal(['linux'])
-    end
-
-    it 'return nil' do
-      family = Train::Platforms.family('fake-fam')
-      scanner.scan_family_children(family).must_be_nil
-      scanner.instance_variable_get(:@family_hierarchy).must_be_empty
-    end
-  end
-
-  describe 'check condition' do
-    it 'return true equal' do
-      scanner.instance_variable_set(:@platform, { arch: 'x86_64' })
-      scanner.check_condition({ arch: '= x86_64' }).must_equal(true)
-    end
-
-    it 'return true greater then' do
-      scanner.instance_variable_set(:@platform, { release: '8.2' })
-      scanner.check_condition({ release: '>= 7' }).must_equal(true)
-    end
-
-    it 'return false greater then' do
-      scanner.instance_variable_set(:@platform, { release: '2.2' })
-      scanner.check_condition({ release: '> 7' }).must_equal(false)
-    end
-  end
-
-  describe 'get platform' do
-    it 'return empty platform' do
-      plat = Train::Platforms.name('linux')
-      plat = scanner.get_platform(plat)
-      plat.platform.must_equal({})
-      plat.backend.must_equal(backend)
-      plat.family_hierarchy.must_equal([])
-    end
-
-    it 'return full platform' do
-      scanner.instance_variable_set(:@platform, { family: 'linux' })
-      scanner.instance_variable_set(:@family_hierarchy, [ 'linux', 'unix' ])
-      plat = Train::Platforms.name('linux')
-      plat = scanner.get_platform(plat)
-      plat.platform.must_equal({ family: 'linux' })
-      plat.backend.must_equal(backend)
-      plat.family_hierarchy.must_equal([ 'linux', 'unix' ])
-    end
-  end
-end