train 0.12.1

data/test/unit/extras/os_detect_windows_test.rb

@@ -0,0 +1,99 @@
+require 'train/extras'
+
+class OsDetectWindowsTester
+  attr_reader :platform, :backend
+  include Train::Extras::DetectWindows
+
+  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
+    }
+
+    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('64-bit')
+      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
+    }
+
+    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('64-bit')
+      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
+    }
+
+    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('32-bit')
+      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
+    }
+
+    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('64-bit')
+      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
+    }
+
+    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_equal(nil)
+      detector.platform[:release].must_equal('4.10.1998')
+    end
+  end
+end

data/test/unit/extras/stat_test.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+require 'helper'
+require 'train/extras'
+
+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) { Minitest::Mock.new }
+
+    it 'ignores wrong stat results' do
+      res = Minitest::Mock.new
+      res.expect :stdout, ''
+      backend.expect :run_command, res, [String]
+      cls.linux_stat('/path', backend, false).must_equal({})
+    end
+
+    it 'reads correct stat results' do
+      res = Minitest::Mock.new
+      # 43ff is 41777; linux_stat strips the 4
+      res.expect :stdout, "360\n43ff\nroot\n0\nrootz\n1\n1444520846\n1444522445\n?"
+      backend.expect :run_command, res, [String]
+      cls.linux_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 '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/extras/windows_file_test.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'helper'
+require 'train/transports/mock'
+require 'train/extras'
+
+describe 'file common' do
+  let(:cls) { Train::Extras::WindowsFile }
+  let(:backend) {
+    backend = Train::Transports::Mock.new.connection
+    backend.mock_os({ family: 'windows' })
+    backend
+  }
+
+  it 'provides the full path' do
+    cls.new(backend, 'C:\dir\file').path.must_equal 'C:\dir\file'
+  end
+
+  it 'provides the basename to a unix path' do
+    cls.new(backend, 'C:\dir\file').basename.must_equal 'file'
+  end
+
+  it 'provides the full path with whitespace' do
+    wf = cls.new(backend, 'C:\Program Files\file name')
+    wf.path.must_equal 'C:\Program Files\file name'
+    wf.basename.must_equal 'file name'
+  end
+
+  it 'reads file contents' do
+    out = rand.to_s
+    backend.mock_command('Get-Content("path") | Out-String', out)
+    cls.new(backend, 'path').content.must_equal out
+  end
+
+  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
+
+  # TODO: add all missing file tests!!
+end

data/test/unit/helper.rb

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

data/test/unit/plugins/connection_test.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'helper'
+
+describe 'v1 Connection Plugin' do
+  describe 'empty v1 connection plugin' do
+    let(:cls) { Train::Plugins::Transport::BaseConnection }
+    let(:connection) { cls.new({}) }
+
+    it 'provides a close method' do
+      connection.close # wont raise
+    end
+
+    it 'provides a run_command method' do
+      proc { connection.run_command('') }.must_raise Train::ClientError
+    end
+
+    it 'provides an os method' do
+      proc { connection.os }.must_raise Train::ClientError
+    end
+
+    it 'provides a file method' do
+      proc { connection.file('') }.must_raise Train::ClientError
+    end
+
+    it 'provides a login command method' do
+      proc { connection.login_command }.must_raise Train::ClientError
+    end
+
+    it 'can wait until ready' do
+      connection.wait_until_ready # wont raise
+    end
+
+    it 'provides a default logger' do
+      connection.method(:logger).call
+                .must_be_instance_of(Logger)
+    end
+
+    it 'must use the user-provided logger' do
+      l = rand
+      cls.new({logger: l})
+         .method(:logger).call.must_equal(l)
+    end
+  end
+end

data/test/unit/plugins/transport_test.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+require 'helper'
+
+describe 'v1 Transport Plugin' do
+  describe 'empty v1 transport plugin' do
+    let(:plugin) { Class.new(Train.plugin(1)) }
+
+    it 'initializes an empty configuration' do
+      plugin.new.options.must_equal({})
+    end
+
+    it 'saves the provided configuration' do
+      conf = { a: rand }
+      plugin.new(conf).options.must_equal(conf)
+    end
+
+    it 'saves the provided configuration' do
+      conf = { a: rand }
+      plugin.new(conf).options.must_equal(conf)
+    end
+
+    it 'provides a default logger' do
+      conf = { a: rand }
+      plugin.new(conf)
+        .method(:logger).call
+        .must_be_instance_of(Logger)
+    end
+
+    it 'can configure custom loggers' do
+      l = rand
+      plugin.new({ logger: l })
+        .method(:logger).call
+        .must_equal(l)
+    end
+
+    it 'provides a connection method' do
+      proc { plugin.new.connection }.must_raise Train::ClientError
+    end
+  end
+
+  describe 'registered with a name' do
+    before do
+      Train::Plugins.registry.clear
+    end
+
+    it 'doesnt have any plugins in the registry if none were configured' do
+      Train::Plugins.registry.empty?.must_equal true
+    end
+
+    it 'is is added to the plugins registry' do
+      plugin_name = rand
+      Train::Plugins.registry.wont_include(plugin_name)
+
+      plugin = Class.new(Train.plugin(1)) do
+        name plugin_name
+      end
+
+      Train::Plugins.registry[plugin_name].must_equal(plugin)
+    end
+  end
+
+  describe 'with options' do
+    def train_class(opts = {})
+      name = rand.to_s
+      plugin = Class.new(Train.plugin(1)) do
+        option name, opts
+      end
+      [name, plugin]
+    end
+
+    it 'exposes the parameters via api' do
+      name, plugin = train_class
+      plugin.default_options.keys.must_equal [name]
+    end
+
+    it 'exposes the parameters via api' do
+      default = rand.to_s
+      name, plugin = train_class({ default: default })
+      plugin.default_options[name][:default].must_equal default
+    end
+
+    it 'option must be required' do
+      name, plugin = train_class(required: true)
+      plugin.default_options[name][:required].must_equal true
+    end
+
+    it 'default option must not be required' do
+      name, plugin = train_class
+      plugin.default_options[name][:required].must_equal nil
+    end
+
+    it 'can include options from another module' do
+      nameA, pluginA = train_class
+      b = Class.new(Train.plugin(1)) do
+        include_options(pluginA)
+      end
+      b.default_options[nameA].wont_be_nil
+    end
+
+    it 'overwrites existing options when including' do
+      old = rand.to_s
+      nu = rand.to_s
+      nameA, pluginA = train_class({ default: nu })
+      b = Class.new(Train.plugin(1)) do
+        option nameA, default: old
+        include_options(pluginA)
+      end
+      b.default_options[nameA][:default].must_equal nu
+    end
+  end
+end