r-train 0.9.1

data/test/unit/helper.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+require 'minitest/autorun'
+require 'minitest/spec'
+
+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

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,132 @@
+# 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
+end

data/test/unit/transports/local_file_test.rb

@@ -0,0 +1,112 @@
+# 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 :readlink, 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(:statres) { stat.new(00140755, rand, (rand*100).to_i, rand, rand) }
+
+    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 :lstat, statres do
+        connection.file(rand.to_s).type.must_equal :socket
+      end
+    end
+
+    it 'recognizes mode' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).mode.must_equal 00755
+      end
+    end
+
+    it 'recognizes mtime' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).mtime.must_equal statres.mtime
+      end
+    end
+
+    it 'recognizes size' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).size.must_equal statres.size
+      end
+    end
+
+    it 'recognizes owner' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).owner.must_equal 'owner'
+      end
+    end
+
+    it 'recognizes group' do
+      meta_stub :lstat, statres do
+        connection.file(rand.to_s).group.must_equal 'group'
+      end
+    end
+
+    it 'recognizes 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).selinux_label.must_equal label
+        end
+      end
+    end
+  end
+
+end

data/test/unit/transports/local_test.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+#
+# author: Dominik Richter
+# author: Christoph Hartmann
+
+require 'helper'
+require 'train/transports/local'
+
+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(:mock) { Minitest::Mock.new }
+
+    def mock_run_cmd(cmd, &block)
+      mock.expect :run_command, nil
+      Mixlib::ShellOut.stub :new, mock do |*args|
+        block.call()
+      end
+    end
+
+    it 'gets stdout' do
+      mock_run_cmd(rand) do
+        x = rand
+        mock.expect :stdout, x
+        mock.expect :stderr, nil
+        mock.expect :exitstatus, nil
+        connection.run_command(rand).stdout.must_equal x
+      end
+    end
+
+    it 'gets stderr' do
+      mock_run_cmd(rand) do
+        x = rand
+        mock.expect :stdout, nil
+        mock.expect :stderr, x
+        mock.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
+        mock.expect :stdout, nil
+        mock.expect :stderr, nil
+        mock.expect :exitstatus, x
+        connection.run_command(rand).exit_status.must_equal x
+      end
+    end
+  end
+end