train 1.5.11 → 1.6.3

data/test/unit/transports/cisco_ios_connection.rb

@@ -1,92 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'train/transports/ssh'
-
-describe 'CiscoIOSConnection' do
-  let(:cls) do
-    Train::Platforms::Detect::Specifications::OS.load
-    plat = Train::Platforms.name('mock').in_family('cisco_ios')
-    plat.add_platform_methods
-    plat.stubs(:cisco_ios?).returns(true)
-    Train::Platforms::Detect.stubs(:scan).returns(plat)
-    Train::Transports::SSH
-  end
-
-  let(:opts) do
-    {
-      host: 'fakehost',
-      user: 'fakeuser',
-      password: 'fakepassword',
-    }
-  end
-
-  let(:connection) do
-    cls.new(opts).connection
-  end
-
-  describe '#initialize' do
-    it 'provides a uri' do
-      connection.uri.must_equal 'ssh://fakeuser@fakehost:22'
-    end
-  end
-
-  describe '#unique_identifier' do
-    it 'returns the correct identifier' do
-      output = "\r\nProcessor board ID 1111111111\r\n"
-      Train::Transports::SSH::CiscoIOSConnection.any_instance
-        .expects(:run_command_via_connection)
-        .with('show version | include Processor')
-        .returns(OpenStruct.new(stdout: output))
-      connection.unique_identifier.must_equal('1111111111')
-    end
-  end
-
-  describe '#format_result' do
-    it 'returns correctly when result is `good`' do
-      output = 'good'
-      Train::Extras::CommandResult.expects(:new).with(output, '', 0)
-      connection.send(:format_result, 'good')
-    end
-
-    it 'returns correctly when result matches /Bad IP address/' do
-      output = "Translating \"nope\"\r\n\r\nTranslating \"nope\"\r\n\r\n% Bad IP address or host name\r\n% Unknown command or computer name, or unable to find computer address\r\n"
-      Train::Extras::CommandResult.expects(:new).with('', output, 1)
-      connection.send(:format_result, output)
-    end
-
-    it 'returns correctly when result matches /Incomplete command/' do
-      output = "% Incomplete command.\r\n\r\n"
-      Train::Extras::CommandResult.expects(:new).with('', output, 1)
-      connection.send(:format_result, output)
-    end
-
-    it 'returns correctly when result matches /Invalid input detected/' do
-      output = "             ^\r\n% Invalid input detected at '^' marker.\r\n\r\n"
-      Train::Extras::CommandResult.expects(:new).with('', output, 1)
-      connection.send(:format_result, output)
-    end
-
-    it 'returns correctly when result matches /Unrecognized host/' do
-      output = "Translating \"nope\"\r\n% Unrecognized host or address, or protocol not running.\r\n\r\n"
-      Train::Extras::CommandResult.expects(:new).with('', output, 1)
-      connection.send(:format_result, output)
-    end
-  end
-
-  describe '#format_output' do
-    it 'returns the correct output' do
-      cmd = 'show calendar'
-      output = "show calendar\r\n10:35:50 UTC Fri Mar 23 2018\r\n7200_ios_12#\r\n7200_ios_12#"
-      result = connection.send(:format_output, output, cmd)
-      result.must_equal '10:35:50 UTC Fri Mar 23 2018'
-    end
-
-    it 'returns the correct output when a pipe is used' do
-      cmd = 'show running-config | section line con 0'
-      output = "show running-config | section line con 0\r\nline con 0\r\n exec-timeout 0 0\r\n privilege level 15\r\n logging synchronous\r\n stopbits 1\r\n7200_ios_12#\r\n7200_ios_12#"
-      result = connection.send(:format_output, output, cmd)
-      result.must_equal "line con 0\r\n exec-timeout 0 0\r\n privilege level 15\r\n logging synchronous\r\n stopbits 1"
-    end
-  end
-end

data/test/unit/transports/gcp_test.rb

@@ -1,266 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-
-describe 'gcp transport' do
-
-  let(:credentials_file) do
-    require 'tempfile'
-    file = Tempfile.new('application_default_credentials.json')
-    info = <<-INFO
-{
-  "client_id": "asdfasf-asdfasdf.apps.googleusercontent.com",
-  "client_secret": "d-asdfasdf",
-  "refresh_token": "1/adsfasdf-lCkju3-yQmjr20xVZonrfkE48L",
-  "type": "authorized_user"
-}
-    INFO
-    file.write(info)
-    file.close
-    file
-  end
-
-  let(:credentials_file_override) do
-    require 'tempfile'
-    file = Tempfile.new('application_default_credentials.json')
-    info = <<-INFO
-{
-  "client_id": "asdfasf-asdfasdf.apps.googleusercontent.com",
-  "client_secret": "d-asdfasdf",
-  "refresh_token": "1/adsfasdf-lCkju3-yQmjr20xVZonrfkE48L",
-  "type": "authorized_user"
-}
-    INFO
-    file.write(info)
-    file.close
-    file
-  end
-
-  def transport(options = nil)
-    ENV['GOOGLE_APPLICATION_CREDENTIALS'] = credentials_file.path
-    ENV['GOOGLE_CLOUD_PROJECT'] = 'test_project'
-    # need to require this at here as it captures the envs on load
-    require 'train/transports/gcp'
-    Train::Transports::Gcp.new(options)
-  end
-
-  let(:connection) { transport.connection }
-  let(:options) { connection.instance_variable_get(:@options) }
-  let(:cache) { connection.instance_variable_get(:@cache) }
-
-  describe 'options' do
-    it 'defaults to env options' do
-      options[:google_application_credentials] = credentials_file.path
-      options[:google_cloud_project].must_equal 'test_project'
-    end
-  end
-
-  it 'allows for options override' do
-    transport = transport(google_application_credentials: credentials_file_override.path, google_cloud_project: "override_project")
-    options = transport.connection.instance_variable_get(:@options)
-    options[:google_application_credentials].must_equal credentials_file_override.path
-    options[:google_cloud_project].must_equal "override_project"
-  end
-
-  describe 'platform' do
-    it 'returns platform' do
-      platform = connection.platform
-      platform.name.must_equal 'gcp'
-      platform.family_hierarchy.must_equal ['cloud', 'api']
-    end
-  end
-
-  describe 'gcp_client' do
-    it 'test gcp_client with caching' do
-      client = connection.gcp_client(Object)
-      client.is_a?(Object).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'test gcp_client without caching' do
-      connection.disable_cache(:api_call)
-      client = connection.gcp_client(Object)
-      client.is_a?(Object).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-  end
-
-
-  describe 'gcp_compute_client' do
-    it 'test gcp_compute_client with caching' do
-      client = connection.gcp_compute_client
-      client.is_a?(Google::Apis::ComputeV1::ComputeService).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'test gcp_client without caching' do
-      connection.disable_cache(:api_call)
-      client = connection.gcp_compute_client
-      client.is_a?(Google::Apis::ComputeV1::ComputeService).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-
-    it 'test gcp_compute_client application name' do
-      client = connection.gcp_compute_client
-      client.is_a?(Google::Apis::ComputeV1::ComputeService).must_equal true
-      client.client_options.application_name.must_equal 'chef-inspec-train'
-    end
-
-    it 'test gcp_compute_client application version' do
-      client = connection.gcp_compute_client
-      client.is_a?(Google::Apis::ComputeV1::ComputeService).must_equal true
-      client.client_options.application_version.must_equal Train::VERSION
-    end
-  end
-
-  describe 'gcp_iam_client' do
-    it 'test gcp_iam_client with caching' do
-      client = connection.gcp_iam_client
-      client.is_a?(Google::Apis::IamV1::IamService).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'test gcp_iam_client without caching' do
-      connection.disable_cache(:api_call)
-      client = connection.gcp_iam_client
-      client.is_a?(Google::Apis::IamV1::IamService).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-
-    it 'test gcp_iam_client application name' do
-      client = connection.gcp_iam_client
-      client.is_a?(Google::Apis::IamV1::IamService).must_equal true
-      client.client_options.application_name.must_equal 'chef-inspec-train'
-    end
-
-    it 'test gcp_iam_client application version' do
-      client = connection.gcp_iam_client
-      client.is_a?(Google::Apis::IamV1::IamService).must_equal true
-      client.client_options.application_version.must_equal Train::VERSION
-    end
-  end
-
-  describe 'gcp_project_client' do
-    it 'test gcp_project_client with caching' do
-      client = connection.gcp_project_client
-      client.is_a?(Google::Apis::CloudresourcemanagerV1::CloudResourceManagerService).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'test gcp_project_client without caching' do
-      connection.disable_cache(:api_call)
-      client = connection.gcp_project_client
-      client.is_a?(Google::Apis::CloudresourcemanagerV1::CloudResourceManagerService).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-
-    it 'test gcp_project_client application name' do
-      client = connection.gcp_project_client
-      client.is_a?(Google::Apis::CloudresourcemanagerV1::CloudResourceManagerService).must_equal true
-      client.client_options.application_name.must_equal 'chef-inspec-train'
-    end
-
-    it 'test gcp_project_client application version' do
-      client = connection.gcp_project_client
-      client.is_a?(Google::Apis::CloudresourcemanagerV1::CloudResourceManagerService).must_equal true
-      client.client_options.application_version.must_equal Train::VERSION
-    end
-  end
-
-  describe 'gcp_storage_client' do
-    it 'test gcp_storage_client with caching' do
-      client = connection.gcp_storage_client
-      client.is_a?(Google::Apis::StorageV1::StorageService).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'test gcp_storage_client without caching' do
-      connection.disable_cache(:api_call)
-      client = connection.gcp_storage_client
-      client.is_a?(Google::Apis::StorageV1::StorageService).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-
-    it 'test gcp_storage_client application name' do
-      client = connection.gcp_storage_client
-      client.is_a?(Google::Apis::StorageV1::StorageService).must_equal true
-      client.client_options.application_name.must_equal 'chef-inspec-train'
-    end
-
-    it 'test gcp_storage_client application version' do
-      client = connection.gcp_storage_client
-      client.is_a?(Google::Apis::StorageV1::StorageService).must_equal true
-      client.client_options.application_version.must_equal Train::VERSION
-    end
-  end
-
-  describe 'gcp_admin_client' do
-    it 'test gcp_admin_client with caching' do
-      client = connection.gcp_admin_client
-      client.is_a?(Google::Apis::AdminDirectoryV1::DirectoryService).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'test gcp_admin_client without caching' do
-      connection.disable_cache(:api_call)
-      client = connection.gcp_admin_client
-      client.is_a?(Google::Apis::AdminDirectoryV1::DirectoryService).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-
-    it 'test gcp_admin_client application name' do
-      client = connection.gcp_admin_client
-      client.is_a?(Google::Apis::AdminDirectoryV1::DirectoryService).must_equal true
-      client.client_options.application_name.must_equal 'chef-inspec-train'
-    end
-
-    it 'test gcp_admin_client application version' do
-      client = connection.gcp_admin_client
-      client.is_a?(Google::Apis::AdminDirectoryV1::DirectoryService).must_equal true
-      client.client_options.application_version.must_equal Train::VERSION
-    end
-  end
-
-  # test options override of env vars in connect
-  describe 'connect' do
-    let(:creds) do
-      require 'tempfile'
-      file = Tempfile.new('creds')
-      info = <<-INFO
-{
-  "client_id": "asdfasf-asdfasdf.apps.googleusercontent.com",
-  "client_secret": "d-asdfasdf",
-  "refresh_token": "1/adsfasdf-lCkju3-yQmjr20xVZonrfkE48L",
-  "type": "authorized_user"
-}
-      INFO
-      file.write(info)
-      file.close
-      file
-    end
-    it 'validate gcp connection with credentials' do
-      options[:google_application_credentials] = creds.path
-      connection.connect
-      ENV['GOOGLE_APPLICATION_CREDENTIALS'].must_equal creds.path
-    end
-    it 'validate gcp connection with project' do
-      options[:google_cloud_project] = 'project'
-      connection.connect
-      ENV['GOOGLE_CLOUD_PROJECT'].must_equal 'project'
-    end
-  end
-
-  describe 'unique_identifier' do
-    it 'test connection unique identifier' do
-      client = connection
-      client.unique_identifier.must_equal 'asdfasf-asdfasdf.apps.googleusercontent.com'
-    end
-  end
-
-  describe 'uri' do
-    it 'test uri' do
-      client = connection
-      client.uri.must_equal 'gcp://asdfasf-asdfasdf.apps.googleusercontent.com'
-    end
-  end
-end

data/test/unit/transports/helpers/azure/file_credentials_test.rb

@@ -1,129 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'tempfile'
-require 'train/transports/helpers/azure/file_credentials'
-
-describe 'parse_credentials_file' do
-  let(:cred_file_single_entry) do
-    file = Tempfile.new('cred_file')
-    info = <<-INFO
-      [my_subscription_id]
-      client_id = "my_client_id"
-      client_secret = "my_client_secret"
-      tenant_id = "my_tenant_id"
-    INFO
-    file.write(info)
-    file.close
-    file
-  end
-
-  let(:cred_file_multiple_entries) do
-    file = Tempfile.new('cred_file')
-    info = <<-INFO
-      [my_subscription_id]
-      client_id = "my_client_id"
-      client_secret = "my_client_secret"
-      tenant_id = "my_tenant_id"
-
-      [my_subscription_id2]
-      client_id = "my_client_id2"
-      client_secret = "my_client_secret2"
-      tenant_id = "my_tenant_id2"
-    INFO
-    file.write(info)
-    file.close
-    file
-  end
-
-  let(:options) { { credentials_file: cred_file_multiple_entries.path } }
-
-  it 'handles a nil file' do
-    options[:credentials_file] = nil
-
-    result = Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-
-    assert_empty(result)
-  end
-
-  it 'returns empty hash when no credentials file detected' do
-    result = Train::Transports::Helpers::Azure::FileCredentials.parse({})
-
-    assert_empty(result)
-  end
-
-  it 'loads only entry from file when no subscription id given' do
-    options[:credentials_file] = cred_file_single_entry.path
-
-    result = Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-
-    assert_equal('my_tenant_id',       result[:tenant_id])
-    assert_equal('my_client_id',       result[:client_id])
-    assert_equal('my_client_secret',   result[:client_secret])
-    assert_equal('my_subscription_id', result[:subscription_id])
-  end
-
-  it 'raises an error when no subscription id given and multiple entries' do
-    error = assert_raises RuntimeError do
-      Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-    end
-
-    assert_equal('Credentials file must have one entry. Check your credentials file. If you have more than one entry set AZURE_SUBSCRIPTION_ID environment variable.', error.message)
-  end
-
-  it 'loads entry when subscription id is given' do
-    options[:subscription_id] = 'my_subscription_id'
-
-    result = Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-
-    assert_equal('my_tenant_id',       result[:tenant_id])
-    assert_equal('my_client_id',       result[:client_id])
-    assert_equal('my_client_secret',   result[:client_secret])
-    assert_equal('my_subscription_id', result[:subscription_id])
-  end
-
-  it 'raises an error when subscription id not found' do
-    options[:subscription_id] = 'missing_subscription_id'
-
-    error = assert_raises RuntimeError do
-      Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-    end
-
-    assert_equal('No credentials found for subscription number missing_subscription_id', error.message)
-  end
-
-  it 'loads entry based on index' do
-    ENV['AZURE_SUBSCRIPTION_NUMBER'] = '2'
-
-    result = Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-
-    ENV.delete('AZURE_SUBSCRIPTION_NUMBER')
-
-    assert_equal('my_tenant_id2',       result[:tenant_id])
-    assert_equal('my_client_id2',       result[:client_id])
-    assert_equal('my_client_secret2',   result[:client_secret])
-    assert_equal('my_subscription_id2', result[:subscription_id])
-  end
-
-  it 'raises an error when index is out of bounds' do
-    ENV['AZURE_SUBSCRIPTION_NUMBER'] = '3'
-
-    error = assert_raises RuntimeError do
-      Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-    end
-    ENV.delete('AZURE_SUBSCRIPTION_NUMBER')
-
-    assert_equal('Your credentials file only contains 2 subscriptions. You specified number 3.', error.message)
-  end
-
-  it 'raises an error when index 0 is given' do
-    ENV['AZURE_SUBSCRIPTION_NUMBER'] = '0'
-
-    error = assert_raises RuntimeError do
-      Train::Transports::Helpers::Azure::FileCredentials.parse(options)
-    end
-    ENV.delete('AZURE_SUBSCRIPTION_NUMBER')
-
-    assert_equal('Index must be greater than 0.', error.message)
-  end
-end

data/test/unit/transports/local_test.rb

@@ -1,183 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'train/transports/local'
-
-class TransportHelper
-  attr_accessor :transport
-
-  def initialize(user_opts = {})
-    opts = {platform_name: 'mock', family_hierarchy: ['mock']}.merge(user_opts)
-    Train::Platforms::Detect::Specifications::OS.load
-    plat = Train::Platforms.name(opts[:platform_name])
-    plat.family_hierarchy = opts[:family_hierarchy]
-    plat.add_platform_methods
-    Train::Platforms::Detect.stubs(:scan).returns(plat)
-    @transport = Train::Transports::Local.new(user_opts)
-  end
-end
-
-describe 'local transport' do
-  let(:transport) { TransportHelper.new.transport }
-  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 'provides a uri' do
-    connection.uri.must_equal 'local://'
-  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
-
-  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 overriding runner selection' do
-    it 'can select the `GenericRunner`' do
-      Train::Transports::Local::Connection::GenericRunner
-        .expects(:new)
-
-      Train::Transports::Local::Connection::WindowsPipeRunner
-        .expects(:new)
-        .never
-
-      Train::Transports::Local::Connection::WindowsShellRunner
-        .expects(:new)
-        .never
-
-      Train::Transports::Local::Connection.new(command_runner: :generic)
-    end
-
-    it 'can select the `WindowsPipeRunner`' do
-      Train::Transports::Local::Connection::GenericRunner
-        .expects(:new)
-        .never
-
-      Train::Transports::Local::Connection::WindowsPipeRunner
-        .expects(:new)
-
-      Train::Transports::Local::Connection::WindowsShellRunner
-        .expects(:new)
-        .never
-
-      Train::Transports::Local::Connection.new(command_runner: :windows_pipe)
-    end
-
-    it 'can select the `WindowsShellRunner`' do
-      Train::Transports::Local::Connection::GenericRunner
-        .expects(:new)
-        .never
-
-      Train::Transports::Local::Connection::WindowsPipeRunner
-        .expects(:new)
-        .never
-
-      Train::Transports::Local::Connection::WindowsShellRunner
-        .expects(:new)
-
-      Train::Transports::Local::Connection.new(command_runner: :windows_shell)
-    end
-
-    it 'throws a RuntimeError when an invalid runner type is passed' do
-      proc { Train::Transports::Local::Connection.new(command_runner: :nope ) }
-        .must_raise(RuntimeError, "Runner type `:nope` not supported")
-    end
-  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
-
-  describe 'when running on Windows' do
-    let(:connection) do
-      TransportHelper.new(family_hierarchy: ['windows']).transport.connection
-    end
-    let(:runner) { mock }
-
-    it 'uses `WindowsPipeRunner` by default' do
-      Train::Transports::Local::Connection::WindowsPipeRunner
-        .expects(:new)
-        .returns(runner)
-
-      Train::Transports::Local::Connection::WindowsShellRunner
-        .expects(:new)
-        .never
-
-      runner.expects(:run_command).with('not actually executed')
-      connection.run_command('not actually executed')
-    end
-
-    it 'uses `WindowsShellRunner` when a named pipe is not available' do
-      Train::Transports::Local::Connection::WindowsPipeRunner
-        .expects(:new)
-        .raises(Train::Transports::Local::PipeError)
-
-      Train::Transports::Local::Connection::WindowsShellRunner
-        .expects(:new)
-        .returns(runner)
-
-      runner.expects(:run_command).with('not actually executed')
-      connection.run_command('not actually executed')
-    end
-  end
-end