train 0.12.1

data/test/unit/plugins_test.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+require 'helper'
+
+describe Train::Plugins do
+  it 'provides a method to create new v1 transport plugins' do
+    Train.plugin(1).must_equal Train::Plugins::Transport
+  end
+
+  it 'fails when called with an unsupported plugin version' do
+    proc {
+      Train.plugin(2)
+    }.must_raise Train::ClientError
+  end
+
+  it 'defaults to v1 plugins' do
+    Train.plugin.must_equal Train::Plugins::Transport
+  end
+
+  it 'provides a registry of plugins' do
+    Train::Plugins.registry.must_be_instance_of(Hash)
+  end
+end

data/test/unit/train_test.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+#
+# Author:: Dominik Richter (<dominik.richter@gmail.com>)
+require 'helper'
+
+describe Train do
+  before do
+    Train::Plugins.registry.clear
+  end
+
+  describe '#create' do
+    it 'raises an error if the plugin isnt found' do
+      proc { Train.create('missing') }.must_raise Train::UserError
+    end
+
+    it 'load a plugin if it isnt in the registry yet via symbol' do
+      Kernel.stub :require, true do
+        ex = Class.new(Train.plugin 1) { name 'existing' }
+        train = Train.create(:existing)
+        train.class.must_equal ex
+      end
+    end
+
+    it 'load a plugin if it isnt in the registry yet via string' do
+      Kernel.stub :require, true do
+        ex = Class.new(Train.plugin 1) { name 'existing' }
+        train = Train.create('existing')
+        train.class.must_equal ex
+      end
+    end
+  end
+
+  describe '#options' do
+    it 'raises exception if a given transport plugin isnt found' do
+      proc { Train.options('missing') }.must_raise Train::UserError
+    end
+
+    it 'provides empty options of a transport plugin' do
+      Class.new(Train.plugin 1) { name 'none' }
+      Train.options('none').must_equal({})
+    end
+
+    it 'provides all options of a transport plugin' do
+      Class.new(Train.plugin 1) {
+        name 'one'
+        option :one, required: true, default: 123
+      }
+      Train.options('one').must_equal({
+        one: {
+          required: true,
+          default: 123,
+        }
+      })
+    end
+  end
+
+  describe '#target_config' do
+    it 'configures resolves target' do
+      org = {
+        target: 'ssh://user:pass@host.com:123/path',
+      }
+      res = Train.target_config(org)
+      res[:backend].must_equal 'ssh'
+      res[:host].must_equal 'host.com'
+      res[:user].must_equal 'user'
+      res[:password].must_equal 'pass'
+      res[:port].must_equal 123
+      res[:target].must_equal org[:target]
+      res[:path].must_equal '/path'
+      org.keys.must_equal [:target]
+    end
+
+    it 'resolves a target while keeping existing fields' do
+      org = {
+        target:   'ssh://user:pass@host.com:123/path',
+        backend:  rand,
+        host:     rand,
+        user:     rand,
+        password: rand,
+        port:     rand,
+        path:     rand
+      }
+      res = Train.target_config(org)
+      res.must_equal org
+    end
+
+    it 'resolves a winrm target' do
+      org = {
+        target:   'winrm://Administrator@192.168.10.140',
+        backend:  'winrm',
+        host:     '192.168.10.140',
+        user:     'Administrator',
+        password: nil,
+        port:     nil,
+        path:     nil
+      }
+      res = Train.target_config(org)
+      res.must_equal org
+    end
+
+    it 'keeps the configuration when incorrect target is supplied' do
+      org = {
+        target: 'wrong',
+      }
+      res = Train.target_config(org)
+      res[:backend].must_be_nil
+      res[:host].must_be_nil
+      res[:user].must_be_nil
+      res[:password].must_be_nil
+      res[:port].must_be_nil
+      res[:path].must_be_nil
+      res[:target].must_equal org[:target]
+    end
+
+    it 'always takes ruby sumbols as configuration fields' do
+      org = {
+        'target'    => 'ssh://user:pass@host.com:123/path',
+        'backend'   => rand,
+        'host'      => rand,
+        'user'      => rand,
+        'password'  => rand,
+        'port'      => rand,
+        'path'      => rand
+      }
+      nu = org.each_with_object({}) { |(x, y), acc|
+        acc[x.to_sym] = y; acc
+      }
+      res = Train.target_config(org)
+      res.must_equal nu
+    end
+  end
+
+  describe '#validate_backend' do
+    it 'just returns the backend if it is provided' do
+      x = rand
+      Train.validate_backend({ backend: x }).must_equal x
+    end
+
+    it 'returns the local backend if nothing was provided' do
+      Train.validate_backend({}).must_equal :local
+    end
+
+    it 'returns the default backend if nothing was provided' do
+      x = rand
+      Train.validate_backend({}, x).must_equal x
+    end
+
+    it 'fails if no backend was given but a target is provided' do
+      proc { Train.validate_backend({ target: rand }) }.must_raise Train::UserError
+    end
+
+    it 'fails if no backend was given but a host is provided' do
+      proc { Train.validate_backend({ host: rand }) }.must_raise Train::UserError
+    end
+  end
+end

data/test/unit/transports/local_file_test.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+#
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'helper'
+require 'train/transports/local'
+
+describe 'local file transport' do
+  let(:transport) { Train::Transports::Local.new }
+  let(:connection) { transport.connection }
+
+  it 'gets file contents' do
+    res = rand.to_s
+    File.stub :read, res do
+      connection.file(rand.to_s).content.must_equal(res)
+    end
+  end
+
+  it 'checks for file existance' do
+    File.stub :exist?, true do
+      connection.file(rand.to_s).exist?.must_equal(true)
+    end
+  end
+
+  {
+    exist?:            :exist?,
+    file?:             :file?,
+    socket?:           :socket?,
+    directory?:        :directory?,
+    symlink?:          :symlink?,
+    pipe?:             :pipe?,
+    character_device?: :chardev?,
+    block_device?:     :blockdev?,
+  }.each do |method, file_method|
+    it "checks if file is a #{method}" do
+      File.stub file_method.to_sym, true do
+        connection.file(rand.to_s).method(method.to_sym).call.must_equal(true)
+      end
+    end
+  end
+
+  it 'checks a file\'s link path' do
+    out = rand.to_s
+    File.stub :realpath, out do
+      File.stub :symlink?, true do
+        connection.file(rand.to_s).link_path.must_equal out
+      end
+    end
+  end
+
+  describe 'file metadata' do
+    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).type.must_equal :socket
+      end
+    end
+
+    it 'recognizes mode' do
+      meta_stub :stat, statres do
+        connection.file(rand.to_s).mode.must_equal 00755
+      end
+    end
+
+    it 'recognizes mtime' do
+      meta_stub :stat, statres do
+        connection.file(rand.to_s).mtime.must_equal statres.mtime
+      end
+    end
+
+    it 'recognizes size' do
+      meta_stub :stat, statres do
+        connection.file(rand.to_s).size.must_equal statres.size
+      end
+    end
+
+    it 'recognizes owner' do
+      meta_stub :stat, statres do
+        connection.file(rand.to_s).owner.must_equal 'owner'
+      end
+    end
+
+    it 'recognizes uid' do
+      meta_stub :stat, statres do
+        connection.file(rand.to_s).uid.must_equal uid
+      end
+    end
+
+    it 'recognizes group' do
+      meta_stub :stat, statres do
+        connection.file(rand.to_s).group.must_equal 'group'
+      end
+    end
+
+    it 'recognizes gid' do
+      meta_stub :stat, statres do
+        connection.file(rand.to_s).gid.must_equal gid
+      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 type' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.type.must_equal :socket
+      end
+    end
+
+    it 'recognizes source mode' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.mode.must_equal 00755
+      end
+    end
+
+    it 'recognizes source mtime' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.mtime.must_equal statres.mtime
+      end
+    end
+
+    it 'recognizes source size' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.size.must_equal statres.size
+      end
+    end
+
+    it 'recognizes source owner' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.owner.must_equal 'owner'
+      end
+    end
+
+    it 'recognizes source uid' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.uid.must_equal uid
+      end
+    end
+
+    it 'recognizes source owner' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.owner.must_equal 'owner'
+      end
+    end
+
+    it 'recognizes source gid' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).source.gid.must_equal gid
+      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
+
+end

data/test/unit/transports/local_test.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+#
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'helper'
+require 'train/transports/local'
+
+# overwrite os detection to simplify mock tests, otherwise run_command tries to
+# determine the OS first and fails the tests
+class Train::Transports::Local::Connection
+  class OS < OSCommon
+    def initialize(backend)
+      super(backend, { family: 'train_mock_os' })
+    end
+
+    def detect_family
+      # no op, we do not need to detect the os
+    end
+  end
+end
+
+describe 'local transport' do
+  let(:transport) { Train::Transports::Local.new }
+  let(:connection) { transport.connection }
+
+  it 'can be instantiated' do
+    transport.wont_be_nil
+  end
+
+  it 'gets the connection' do
+    connection.must_be_kind_of Train::Transports::Local::Connection
+  end
+
+  it 'doesnt wait to be read' do
+    connection.wait_until_ready.must_be_nil
+  end
+
+  it 'can be closed' do
+    connection.close.must_be_nil
+  end
+
+  it 'has no login command' do
+    connection.login_command.must_be_nil
+  end
+
+  describe 'when running a local command' do
+    let(:cmd_runner) { Minitest::Mock.new }
+
+    def mock_run_cmd(cmd, &block)
+      cmd_runner.expect :run_command, nil
+      Mixlib::ShellOut.stub :new, cmd_runner do |*args|
+        block.call()
+      end
+    end
+
+    it 'gets stdout' do
+      mock_run_cmd(rand) do
+        x = rand
+        cmd_runner.expect :stdout, x
+        cmd_runner.expect :stderr, nil
+        cmd_runner.expect :exitstatus, nil
+        connection.run_command(rand).stdout.must_equal x
+      end
+    end
+
+    it 'gets stderr' do
+      mock_run_cmd(rand) do
+        x = rand
+        cmd_runner.expect :stdout, nil
+        cmd_runner.expect :stderr, x
+        cmd_runner.expect :exitstatus, nil
+        connection.run_command(rand).stderr.must_equal x
+      end
+    end
+
+    it 'gets exit_status' do
+      mock_run_cmd(rand) do
+        x = rand
+        cmd_runner.expect :stdout, nil
+        cmd_runner.expect :stderr, nil
+        cmd_runner.expect :exitstatus, x
+        connection.run_command(rand).exit_status.must_equal x
+      end
+    end
+  end
+end