train 1.5.11 → 1.6.3

data/test/unit/transports/mock_test.rb

@@ -1,150 +0,0 @@
-# encoding: utf-8
-require 'helper'
-require 'train/transports/mock'
-require 'digest/sha2'
-
-describe 'mock transport' do
-  let(:transport) { Train::Transports::Mock.new(verbose: true) }
-  let(:connection) { transport.connection }
-
-  it 'can be instantiated' do
-    transport.wont_be_nil
-  end
-
-  it 'can create a connection' do
-    connection.wont_be_nil
-  end
-
-  it 'provides a uri' do
-    connection.uri.must_equal 'mock://'
-  end
-
-  it 'provides a run_command_via_connection method' do
-    methods = connection.class.private_instance_methods(false)
-    methods.include?(:run_command_via_connection).must_equal true
-  end
-
-  it 'provides a file_via_connection method' do
-    methods = connection.class.private_instance_methods(false)
-    methods.include?(:file_via_connection).must_equal true
-  end
-
-  describe 'when running a mocked command' do
-    let(:mock_cmd) {  }
-
-    it 'has a simple mock command creator' do
-      out = rand
-      cls = Train::Transports::Mock::Connection::Command
-      res = cls.new(out, '', 0)
-      connection.mock_command('test', out).must_equal res
-    end
-
-    it 'handles nil commands' do
-      connection.run_command(nil).stdout.must_equal('')
-    end
-
-    it 'can mock up nil commands' do
-      out = rand
-      connection.mock_command('', rand) # don't pull this result! always mock the input
-      connection.mock_command(nil, out) # pull this result
-      connection.run_command(nil).stdout.must_equal(out)
-    end
-
-    it 'gets results for stdout' do
-      out = rand
-      cmd = rand
-      connection.mock_command(cmd, out)
-      connection.run_command(cmd).stdout.must_equal(out)
-    end
-
-    it 'gets results for stderr' do
-      err = rand
-      cmd = rand
-      connection.mock_command(cmd, nil, err)
-      connection.run_command(cmd).stderr.must_equal(err)
-    end
-
-    it 'gets results for exit_status' do
-      code = rand
-      cmd = rand
-      connection.mock_command(cmd, nil, nil, code)
-      connection.run_command(cmd).exit_status.must_equal(code)
-    end
-
-    it 'can mock a command via its SHA2 sum' do
-      out = rand.to_s
-      cmd = rand.to_s
-      shacmd = Digest::SHA256.hexdigest cmd
-      connection.mock_command(shacmd, out)
-      connection.run_command(cmd).stdout.must_equal(out)
-    end
-  end
-
-  describe 'when accessing a mocked os' do
-    it 'has the default mock os faily set to mock' do
-      connection.os[:name].must_equal 'mock'
-      connection.platform[:name].must_equal 'mock'
-    end
-
-    it 'sets the OS to the mocked value' do
-      connection.mock_os({ name: 'centos', family: 'redhat' })
-      connection.os.linux?.must_equal true
-      connection.os.redhat?.must_equal true
-      connection.os[:family].must_equal 'redhat'
-    end
-
-    it 'allows the setting of the name' do
-      connection.mock_os({ name: 'foo' })
-      connection.os[:name].must_equal 'foo'
-    end
-
-    it 'allows setting of the family' do
-      connection.mock_os({ family: 'foo' })
-      connection.os[:family].must_equal 'foo'
-    end
-
-    it 'allows setting of the release' do
-      connection.mock_os({ release: '1.2.3' })
-      connection.os[:release].must_equal '1.2.3'
-    end
-
-    it 'allows setting of the arch' do
-      connection.mock_os({ arch: 'amd123' })
-      connection.os[:arch].must_equal 'amd123'
-    end
-
-    it 'allow setting of multiple values' do
-      connection.mock_os({ name: 'foo', family: 'bar' })
-      connection.os[:name].must_equal 'foo'
-      connection.os[:family].must_equal 'bar'
-      connection.os[:arch].must_equal 'unknown'
-      connection.os[:release].must_equal 'unknown'
-    end
-
-    it 'properly handles a nil value' do
-      connection.mock_os(nil)
-      connection.os[:name].must_equal 'mock'
-      connection.os[:family].must_equal 'mock'
-    end
-  end
-
-  describe 'when accessing a mocked file' do
-    it 'handles a non-existing file' do
-      x = rand.to_s
-      f = connection.file(x)
-      f.must_be_kind_of Train::Transports::Mock::Connection::File
-      f.exist?.must_equal false
-      f.path.must_equal x
-    end
-
-    # tests if all fields between the local json and resulting mock file
-    # are equal
-    JSON_DATA = Train.create('local').connection.file(__FILE__).to_json
-    RES = Train::Transports::Mock::Connection::File.from_json(JSON_DATA)
-    %w{ content mode owner group }.each do |f|
-      it "can be initialized from json (field #{f})" do
-        RES.method(f).call.must_equal JSON_DATA[f]
-      end
-    end
-  end
-end

data/test/unit/transports/ssh_test.rb

@@ -1,330 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'train/transports/ssh'
-
-describe 'ssh transport' do
-  let(:cls) do
-    plat = Train::Platforms.name('mock').in_family('linux')
-    plat.add_platform_methods
-    Train::Platforms::Detect.stubs(:scan).returns(plat)
-    Train::Transports::SSH
-  end
-  let(:conf) {{
-    host: rand.to_s,
-    password: rand.to_s,
-    key_files: rand.to_s,
-    proxy_command: 'ssh root@127.0.0.1 -W %h:%p',
-  }}
-  let(:cls_agent) { cls.new({ host: rand.to_s }) }
-
-  describe 'default options' do
-    let(:ssh) { cls.new({ host: 'dummy' }) }
-
-    it 'can be instantiated (with valid config)' do
-      ssh.wont_be_nil
-    end
-
-    it 'configures the host' do
-      ssh.options[:host].must_equal 'dummy'
-    end
-
-    it 'has default port' do
-      ssh.options[:port].must_equal 22
-    end
-
-    it 'has default user' do
-      ssh.options[:user].must_equal 'root'
-    end
-
-    it 'by default does not request a pty' do
-      ssh.options[:pty].must_equal false
-    end
-  end
-
-  describe 'connection options' do
-    let(:ssh) { cls.new({ host: 'dummy' }) }
-    let(:connection_options) { ssh.send(:connection_options, {}) }
-
-    it 'does not set a paranoid option - deprecated in net-ssh 4.2' do
-      connection_options.key?(:paranoid).must_equal false
-    end
-
-    it 'sets a verify_host_key option, replacement for paranoid' do
-      connection_options[:verify_host_key].must_equal false
-    end
-  end
-
-  describe 'ssh options' do
-    let(:ssh) { cls.new(conf) }
-    let(:connection) { ssh.connection }
-    it 'includes BatchMode when :non_interactive is set' do
-      conf[:non_interactive] = true
-      connection.ssh_opts.include?("BatchMode=yes").must_equal true
-    end
-    it 'excludes BatchMode when :non_interactive is not set' do
-      connection.ssh_opts.include?("BatchMode=yes").must_equal false
-    end
-  end
-
-  describe 'opening a connection' do
-    let(:ssh) { cls.new(conf) }
-    let(:connection) { ssh.connection }
-
-    it 'provides a run_command_via_connection method' do
-      methods = connection.class.private_instance_methods(false)
-      methods.include?(:run_command_via_connection).must_equal true
-    end
-
-    it 'provides a file_via_connection method' do
-      methods = connection.class.private_instance_methods(false)
-      methods.include?(:file_via_connection).must_equal true
-    end
-
-    it 'gets the connection' do
-      connection.must_be_kind_of Train::Transports::SSH::Connection
-    end
-
-    it 'provides a uri' do
-      connection.uri.must_equal "ssh://root@#{conf[:host]}:22"
-    end
-
-    it 'must respond to wait_until_ready' do
-      connection.must_respond_to :wait_until_ready
-    end
-
-    it 'can be closed' do
-      connection.close.must_be_nil
-    end
-
-    it 'has a login command == ssh' do
-      connection.login_command.command.must_equal 'ssh'
-    end
-
-    it 'has login command arguments' do
-      connection.login_command.arguments.must_equal([
-        "-o", "UserKnownHostsFile=/dev/null",
-        "-o", "StrictHostKeyChecking=no",
-        "-o", "IdentitiesOnly=yes",
-        "-o", "LogLevel=VERBOSE",
-        "-o", "ForwardAgent=no",
-        "-i", conf[:key_files],
-        "-o", "ProxyCommand='ssh root@127.0.0.1 -W %h:%p'",
-        "-p", "22",
-        "root@#{conf[:host]}",
-      ])
-    end
-
-    it 'sets the right auth_methods when password is specified' do
-      conf[:key_files] = nil
-      cls.new(conf).connection.method(:options).call[:auth_methods].must_equal ["none", "password", "keyboard-interactive"]
-    end
-
-    it 'sets the right auth_methods when keys are specified' do
-      conf[:password] = nil
-      cls.new(conf).connection.method(:options).call[:auth_methods].must_equal ["none", "publickey"]
-    end
-
-    it 'sets the right auth_methods for agent auth' do
-      cls_agent.stubs(:ssh_known_identities).returns({:some => 'rsa_key'})
-      cls_agent.connection.method(:options).call[:auth_methods].must_equal ['none', 'publickey']
-    end
-
-    it 'works with ssh agent auth' do
-      cls_agent.stubs(:ssh_known_identities).returns({:some => 'rsa_key'})
-      cls_agent.connection
-    end
-
-    it 'sets up a proxy when ssh proxy command is specified' do
-      mock = MiniTest::Mock.new
-      mock.expect(:call, true) do |hostname, username, options|
-        options[:proxy].kind_of?(Net::SSH::Proxy::Command) &&
-          'ssh root@127.0.0.1 -W %h:%p' == options[:proxy].command_line_template
-      end
-      connection.stubs(:run_command)
-      Net::SSH.stub(:start, mock) do
-        connection.wait_until_ready
-      end
-      mock.verify
-    end
-  end
-
-  describe 'converting connection to string for logging' do
-   it 'masks passwords' do
-      assert_output(/.*:password=>"<hidden>".*/) do
-        connection = cls.new(conf).connection
-        puts "#{connection}"
-      end
-    end
-  end
-
-  describe 'failed configuration' do
-    it 'works with a minimum valid config' do
-      cls.new(conf).connection
-    end
-
-    it 'does not like host == nil' do
-      conf.delete(:host)
-      proc { cls.new(conf).connection }.must_raise Train::ClientError
-    end
-
-    it 'reverts to root on user == nil' do
-      conf[:user] = nil
-      cls.new(conf).connection.method(:options).call[:user] == 'root'
-    end
-
-    it 'does not like key and password == nil' do
-      cls_agent.stubs(:ssh_known_identities).returns({})
-      proc { cls_agent.connection }.must_raise Train::ClientError
-    end
-
-    it 'wont connect if it is not possible' do
-      conf[:host] = 'localhost'
-      conf[:port] = 1
-      conf.delete :proxy_command
-      conn = cls.new(conf).connection
-      proc { conn.run_command('uname') }.must_raise Train::Transports::SSHFailed
-    end
-  end
-end
-
-describe 'ssh transport with bastion' do
-  let(:cls) do
-    plat = Train::Platforms.name('mock').in_family('linux')
-    plat.add_platform_methods
-    Train::Platforms::Detect.stubs(:scan).returns(plat)
-    Train::Transports::SSH
-  end
-
-  let(:conf) {{
-    host: rand.to_s,
-    password: rand.to_s,
-    key_files: rand.to_s,
-    bastion_host: 'bastion_dummy',
-  }}
-  let(:cls_agent) { cls.new({ host: rand.to_s }) }
-
-  describe 'bastion' do
-    describe 'default options' do
-      let(:ssh) { cls.new({ bastion_host: 'bastion_dummy' }) }
-
-      it 'configures the host' do
-        ssh.options[:bastion_host].must_equal 'bastion_dummy'
-      end
-
-      it 'has default port' do
-        ssh.options[:bastion_port].must_equal 22
-      end
-
-      it 'has default user' do
-        ssh.options[:bastion_user].must_equal 'root'
-      end
-    end
-
-    describe 'opening a connection' do
-      let(:ssh) { cls.new(conf) }
-      let(:connection) { ssh.connection }
-
-      it 'provides a run_command_via_connection method' do
-        methods = connection.class.private_instance_methods(false)
-        methods.include?(:run_command_via_connection).must_equal true
-      end
-
-      it 'provides a file_via_connection method' do
-        methods = connection.class.private_instance_methods(false)
-        methods.include?(:file_via_connection).must_equal true
-      end
-
-      it 'gets the connection' do
-        connection.must_be_kind_of Train::Transports::SSH::Connection
-      end
-
-      it 'provides a uri' do
-        connection.uri.must_equal "ssh://root@#{conf[:host]}:22"
-      end
-
-      it 'must respond to wait_until_ready' do
-        connection.must_respond_to :wait_until_ready
-      end
-
-      it 'can be closed' do
-        connection.close.must_be_nil
-      end
-
-      it 'has a login command == ssh' do
-        connection.login_command.command.must_equal 'ssh'
-      end
-
-      it 'has login command arguments' do
-        connection.login_command.arguments.must_equal([
-          "-o", "UserKnownHostsFile=/dev/null",
-          "-o", "StrictHostKeyChecking=no",
-          "-o", "IdentitiesOnly=yes",
-          "-o", "LogLevel=VERBOSE",
-          "-o", "ForwardAgent=no",
-          "-i", conf[:key_files],
-          "-o", "ProxyCommand='ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o IdentitiesOnly=yes -o LogLevel=VERBOSE -o ForwardAgent=no -i #{conf[:key_files]} root@bastion_dummy -p 22 -W %h:%p'",
-          "-p", "22",
-          "root@#{conf[:host]}",
-        ])
-      end
-
-      it 'sets the right auth_methods when password is specified' do
-        conf[:key_files] = nil
-        cls.new(conf).connection.method(:options).call[:auth_methods].must_equal ["none", "password", "keyboard-interactive"]
-      end
-
-      it 'sets the right auth_methods when keys are specified' do
-        conf[:password] = nil
-        cls.new(conf).connection.method(:options).call[:auth_methods].must_equal ["none", "publickey"]
-      end
-
-      it 'sets the right auth_methods for agent auth' do
-        cls_agent.stubs(:ssh_known_identities).returns({:some => 'rsa_key'})
-        cls_agent.connection.method(:options).call[:auth_methods].must_equal ['none', 'publickey']
-      end
-
-      it 'works with ssh agent auth' do
-        cls_agent.stubs(:ssh_known_identities).returns({:some => 'rsa_key'})
-        cls_agent.connection
-      end
-
-      it 'sets up a proxy when ssh proxy command is specified' do
-        mock = MiniTest::Mock.new
-        mock.expect(:call, true) do |hostname, username, options|
-          options[:proxy].kind_of?(Net::SSH::Proxy::Command) &&
-            "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -o IdentitiesOnly=yes -o LogLevel=VERBOSE -o ForwardAgent=no -i #{conf[:key_files]} root@bastion_dummy -p 22 -W %h:%p" == options[:proxy].command_line_template
-        end
-        connection.stubs(:run_command)
-        Net::SSH.stub(:start, mock) do
-          connection.wait_until_ready
-        end
-        mock.verify
-      end
-    end
-  end
-end
-
-describe 'ssh transport with bastion and proxy' do
-  let(:cls) do
-    plat = Train::Platforms.name('mock').in_family('linux')
-    plat.add_platform_methods
-    Train::Platforms::Detect.stubs(:scan).returns(plat)
-    Train::Transports::SSH
-  end
-
-  let(:conf) {{
-    host: rand.to_s,
-    password: rand.to_s,
-    key_files: rand.to_s,
-    bastion_host: 'bastion_dummy',
-    proxy_command: 'dummy'
-  }}
-  let(:cls_agent) { cls.new({ host: rand.to_s }) }
-
-  describe 'bastion and proxy' do
-    it 'will throw an exception when both proxy_command and bastion_host is specified' do
-      proc { cls.new(conf).connection }.must_raise Train::ClientError
-    end
-  end
-end

data/test/unit/transports/vmware_test.rb

@@ -1,159 +0,0 @@
-# encoding: utf-8
-require 'helper'
-
-describe 'Train::Transports::VMware::Connection' do
-  def add_stubs(stub_options)
-    Train::Transports::VMware::Connection.any_instance
-      .stubs(:detect_powershell_binary)
-      .returns(stub_options[:powershell_binary] || :pwsh)
-    Train::Transports::VMware::Connection.any_instance
-      .stubs(:powercli_version)
-      .returns('10.1.1.8827525')
-    Train::Transports::VMware::Connection.any_instance
-      .stubs(:run_command_via_connection)
-      .with('(Get-VMHost | Get-View).hardware.systeminfo.uuid')
-      .returns(stub_options[:mock_uuid_result] || nil)
-    if stub_options[:mock_connect_result]
-      Train::Transports::VMware::Connection.any_instance
-        .expects(:run_command_via_connection)
-        .with('Connect-VIServer 10.0.0.10 -User testuser -Password supersecurepassword | Out-Null')
-        .returns(stub_options[:mock_connect_result])
-    else
-      Train::Transports::VMware::Connection.any_instance
-        .stubs(:connect)
-        .returns(nil)
-    end
-  end
-
-  def create_transport(options = {})
-    ENV['VISERVER'] = '10.0.0.10'
-    ENV['VISERVER_USERNAME'] = 'testuser'
-    ENV['VISERVER_PASSWORD'] = 'supersecurepassword'
-
-    # Need to require this here as it captures the ENV variables on load
-    require 'train/transports/vmware'
-    add_stubs(options[:stub_options] || {})
-    Train::Transports::VMware.new(options[:transport_options])
-  end
-
-  describe '#initialize' do
-    it 'defaults to ENV options' do
-      options = create_transport.connection.instance_variable_get(:@options)
-      options[:viserver].must_equal '10.0.0.10'
-      options[:username].must_equal 'testuser'
-      options[:password].must_equal 'supersecurepassword'
-      options[:insecure].must_equal false
-    end
-
-    it 'allows for overriding options' do
-      transport = create_transport(
-        transport_options: {
-          viserver: '10.1.1.1',
-          username: 'anotheruser',
-          password: 'notsecurepassword',
-          insecure: false,
-        }
-      )
-      options = transport.connection.instance_variable_get(:@options)
-      options[:viserver].must_equal '10.1.1.1'
-      options[:username].must_equal 'anotheruser'
-      options[:password].must_equal 'notsecurepassword'
-      options[:insecure].must_equal false
-    end
-
-    it 'ignores certificate validation if --insecure is used' do
-      Train::Transports::VMware::Connection.any_instance
-        .expects(:run_command_via_connection)
-        .with('Set-PowerCLIConfiguration -InvalidCertificateAction Ignore -Scope Session -Confirm:$False')
-        .returns(nil)
-      transport = create_transport(transport_options: { insecure: true })
-      options = transport.connection.instance_variable_get(:@options)
-      options[:insecure].must_equal true
-    end
-
-    it 'uses the Local connection when Windows PowerShell is found' do
-      require 'train/transports/local'
-      Train::Transports::Local::Connection.expects(:new)
-      create_transport(
-        stub_options: {
-          powershell_binary: :powershell
-        }
-      ).connection
-    end
-  end
-
-  describe '#connect' do
-    def mock_connect_result(stderr, exit_status)
-      OpenStruct.new(stderr: stderr, exit_status: exit_status)
-    end
-
-    it 'raises certificate error when stderr matches regular expression' do
-      e = proc {
-        create_transport(
-          stub_options: {
-            mock_connect_result: mock_connect_result(
-              'Invalid server certificate', 1
-            )
-          }
-        ).connection
-      }.must_raise(RuntimeError)
-      e.message.must_match /Unable to connect.*Please use `--insecure`/
-    end
-
-    it 'raises auth error when stderr matches regular expression' do
-      e = proc {
-        create_transport(
-          stub_options: {
-            mock_connect_result: mock_connect_result(
-              'incorrect user name or password', 1
-            )
-          }
-        ).connection
-      }.must_raise(RuntimeError)
-      e.message.must_match /Unable to connect.*Incorrect username/
-    end
-
-    it 'redacts the password when an unspecified error is raised' do
-      e = proc {
-        create_transport(
-          stub_options: {
-            mock_connect_result: mock_connect_result(
-              'something unexpected -Password supersecret -AnotherOption', 1
-            )
-          }
-        ).connection
-      }.must_raise(RuntimeError)
-      e.message.must_match /-Password REDACTED/
-    end
-  end
-
-  describe '#platform' do
-    it 'returns correct platform details' do
-      platform = create_transport.connection.platform
-      platform.clean_name.must_equal 'vmware'
-      platform.family_hierarchy.must_equal ['cloud', 'api']
-      platform.platform.must_equal(release: 'vmware-powercli-10.1.1.8827525')
-      platform.vmware?.must_equal true
-    end
-  end
-
-  describe '#unique_identifier' do
-    it 'returns the correct unique identifier' do
-      uuid = '1f261432-e23e-6911-841c-94c6911a02dd'
-      mock_uuid_result = OpenStruct.new(
-        stdout: uuid + "\n"
-      )
-      connection = create_transport(
-        stub_options: { mock_uuid_result: mock_uuid_result }
-      ).connection
-
-      connection.unique_identifier.must_equal(uuid)
-    end
-  end
-
-  describe '#uri' do
-    it 'returns the correct URI' do
-      create_transport.connection.uri.must_equal 'vmware://testuser@10.0.0.10'
-    end
-  end
-end

data/test/unit/version_test.rb

@@ -1,8 +0,0 @@
-# encoding: utf-8
-require 'helper'
-
-describe Train do
-  it 'defines a version' do
-    Train::VERSION.must_be_instance_of String
-  end
-end