train 1.5.11 → 1.6.3

data/test/unit/plugins/transport_test.rb

@@ -1,111 +0,0 @@
-# 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_be_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

@@ -1,22 +0,0 @@
-# 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

@@ -1,247 +0,0 @@
-# encoding: utf-8
-#
-# Author:: Dominik Richter (<dominik.richter@gmail.com>)
-require_relative '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
-      proc { Train.create('missing') }.must_raise Train::PluginLoadError
-    end
-
-    it 'loads a core 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 'loads a core 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
-
-    it 'loads a gem plugin if it isnt in the registry yet via string' do
-      # The 'train-test-fixture' gem is located in test/fixtures/plugins/train-test-fixture and is
-      # lib/train/trainsports, and Train will need to pre-pend 'train-' to the
-      # transport name to get the gem name.
-      transport = Train.create('test-fixture')
-      # Normally one would call transport.class.name, but that's been overridden to be a write-only DSL method
-      # So use to_s
-      transport.class.to_s.must_equal 'TrainPlugins::TestFixture::Transport'
-    end
-  end
-
-  describe '#options' do
-    it 'raises exception if a given transport plugin isnt found' do
-      proc { Train.options('missing') }.must_raise Train::UserError
-      proc { Train.options('missing') }.must_raise Train::PluginLoadError
-    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
-
-    it 'supports IPv4 URIs' do
-      org = { target: 'mock://1.2.3.4:123' }
-      res = Train.target_config(org)
-      res[:backend].must_equal 'mock'
-      res[:host].must_equal '1.2.3.4'
-      res[:user].must_be_nil
-      res[:password].must_be_nil
-      res[:port].must_equal 123
-      res[:path].must_be_nil
-      res[:target].must_equal org[:target]
-    end
-
-    it 'supports IPv6 URIs' do
-      org = { target: 'mock://[abc::def]:123' }
-      res = Train.target_config(org)
-      res[:backend].must_equal 'mock'
-      res[:host].must_equal 'abc::def'
-      res[:user].must_be_nil
-      res[:password].must_be_nil
-      res[:port].must_equal 123
-      res[:path].must_be_nil
-      res[:target].must_equal org[:target]
-    end
-
-    it 'supports empty URIs with schema://' do
-      org = { target: 'mock://' }
-      res = Train.target_config(org)
-      res[:backend].must_equal 'mock'
-      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 'supports empty URIs with schema:' do
-      org = { target: 'mock:' }
-      res = Train.target_config(org)
-      res[:backend].must_equal 'mock'
-      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 'supports www-form encoded passwords when the option is set' do
-      raw_password = '+!@#$%^&*()_-\';:"\\|/?.>,<][}{=`~'
-      encoded_password = URI.encode_www_form_component(raw_password)
-      org = { target: "mock://username:#{encoded_password}@1.2.3.4:100",
-              www_form_encoded_password: true}
-      res = Train.target_config(org)
-      res[:backend].must_equal 'mock'
-      res[:host].must_equal '1.2.3.4'
-      res[:user].must_equal 'username'
-      res[:password].must_equal raw_password
-      res[:port].must_equal 100
-      res[:target].must_equal org[:target]
-    end
-
-    it 'ignores www-form-encoded password value when there is no password' do
-      org = { target: "mock://username@1.2.3.4:100",
-              www_form_encoded_password: true}
-      res = Train.target_config(org)
-      res[:backend].must_equal 'mock'
-      res[:host].must_equal '1.2.3.4'
-      res[:user].must_equal 'username'
-      res[:password].must_be_nil
-      res[:port].must_equal 100
-      res[:target].must_equal org[:target]
-    end
-
-    it 'it raises UserError on invalid URIs' do
-      org = { target: 'mock world' }
-      proc { Train.target_config(org) }.must_raise Train::UserError
-    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/aws_test.rb

@@ -1,120 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-
-describe 'aws transport' do
-  def transport(options = nil)
-    ENV['AWS_REGION'] = 'test_region'
-    ENV['AWS_ACCESS_KEY_ID'] = 'test_key_id'
-    ENV['AWS_SECRET_ACCESS_KEY'] = 'test_access_key'
-    ENV['AWS_SESSION_TOKEN'] = 'test_session_token'
-
-    # need to require this at here as it captures the envs on load
-    require 'train/transports/aws'
-    Train::Transports::Aws.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[:region].must_equal 'test_region'
-      options[:access_key_id].must_equal 'test_key_id'
-      options[:secret_access_key].must_equal 'test_access_key'
-      options[:session_token].must_equal 'test_session_token'
-    end
-
-    it 'test options override' do
-      transport = transport(region: 'us-east-2', access_key_id: '8')
-      options = transport.connection.instance_variable_get(:@options)
-      options[:region].must_equal 'us-east-2'
-      options[:access_key_id].must_equal '8'
-      options[:secret_access_key].must_equal 'test_access_key'
-      options[:session_token].must_equal 'test_session_token'
-    end
-
-    it 'test url parse override' do
-      transport = transport(host: 'us-east-2')
-      options = transport.connection.instance_variable_get(:@options)
-      options[:region].must_equal 'us-east-2'
-      options[:session_token].must_equal 'test_session_token'
-    end
-  end
-
-  describe 'platform' do
-    it 'returns platform' do
-      plat = connection.platform
-      plat.name.must_equal 'aws'
-      plat.family_hierarchy.must_equal ['cloud', 'api']
-    end
-  end
-
-  describe 'aws_client' do
-    it 'test aws_client with caching' do
-      client = connection.aws_client(Object)
-      client.is_a?(Object).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'test aws_client without caching' do
-      connection.disable_cache(:api_call)
-      client = connection.aws_client(Object)
-      client.is_a?(Object).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-  end
-
-  describe 'aws_resource' do
-    class AwsResource
-      attr_reader :hash
-      def initialize(hash)
-        @hash = hash
-      end
-    end
-
-    it 'test aws_resource with arguments' do
-      hash = { user: 1, name: 'test_user' }
-      resource = connection.aws_resource(AwsResource, hash)
-      resource.hash.must_equal hash
-      cache[:api_call].count.must_equal 0
-    end
-  end
-
-  describe 'connect' do
-    it 'validate aws connection with profile' do
-      options[:profile] = 'xyz'
-      ENV['AWS_PROFILE'].must_be_nil
-      connection.connect
-      ENV['AWS_PROFILE'].must_equal 'xyz'
-    end
-
-    it 'validate aws connection with region' do
-      options[:region] = 'xyz'
-      ENV['AWS_REGION'].must_equal 'test_region'
-      connection.connect
-      ENV['AWS_REGION'].must_equal 'xyz'
-    end
-  end
-
-  describe 'unique_identifier' do
-
-    class AwsCallerId
-      def account
-        "123456789012"
-      end
-    end
-
-    class StsClient
-      def get_caller_identity
-        AwsCallerId.new
-      end
-    end
-
-    it 'returns an account id' do
-      connection.stubs(:aws_client).returns(StsClient.new)
-      connection.unique_identifier.must_equal '123456789012'
-    end
-  end
-
-end

data/test/unit/transports/azure_test.rb

@@ -1,145 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-
-describe 'azure transport' do
-  def transport(options = nil)
-    ENV['AZURE_TENANT_ID'] = 'test_tenant_id'
-    ENV['AZURE_CLIENT_ID'] = 'test_client_id'
-    ENV['AZURE_CLIENT_SECRET'] = 'test_client_secret'
-    ENV['AZURE_SUBSCRIPTION_ID'] = 'test_subscription_id'
-
-    # need to require this at here as it captures the envs on load
-    require 'train/transports/azure'
-    Train::Transports::Azure.new(options)
-  end
-  let(:connection) { transport.connection }
-  let(:options) { connection.instance_variable_get(:@options) }
-  let(:cache) { connection.instance_variable_get(:@cache) }
-  let(:credentials) { connection.instance_variable_get(:@credentials) }
-
-  describe 'options' do
-    it 'defaults to env options' do
-      options[:tenant_id].must_equal 'test_tenant_id'
-      options[:client_id].must_equal 'test_client_id'
-      options[:client_secret].must_equal 'test_client_secret'
-      options[:subscription_id].must_equal 'test_subscription_id'
-    end
-
-    it 'allows for options override' do
-      transport = transport(subscription_id: '102', client_id: '717')
-      options = transport.connection.instance_variable_get(:@options)
-      options[:tenant_id].must_equal 'test_tenant_id'
-      options[:client_id].must_equal '717'
-      options[:client_secret].must_equal 'test_client_secret'
-      options[:subscription_id].must_equal '102'
-    end
-
-    it 'allows uri parse override' do
-      transport = transport(host: '999')
-      options = transport.connection.instance_variable_get(:@options)
-      options[:tenant_id].must_equal 'test_tenant_id'
-      options[:subscription_id].must_equal '999'
-    end
-  end
-
-  describe 'platform' do
-    it 'returns platform' do
-      plat = connection.platform
-      plat.name.must_equal 'azure'
-      plat.family_hierarchy.must_equal ['cloud', 'api']
-    end
-  end
-
-  describe 'azure_client' do
-    class AzureResource
-      attr_reader :hash
-      def initialize(hash)
-        @hash = hash
-      end
-    end
-
-    it 'can use azure_client with caching' do
-      connection.instance_variable_set(:@credentials, {})
-      client = connection.azure_client(AzureResource)
-      client.is_a?(AzureResource).must_equal true
-      cache[:api_call].count.must_equal 1
-    end
-
-    it 'can use azure_client without caching' do
-      connection.instance_variable_set(:@credentials, {})
-      connection.disable_cache(:api_call)
-      client = connection.azure_client(AzureResource)
-      client.is_a?(AzureResource).must_equal true
-      cache[:api_call].count.must_equal 0
-    end
-
-    it 'can use azure_client default client' do
-      MANAGEMENT_API_CLIENT = Azure::Resources::Profiles::Latest::Mgmt::Client
-      client = connection.azure_client
-      client.class.must_equal MANAGEMENT_API_CLIENT
-    end
-
-    it 'can use azure_client graph client' do
-      GRAPH_API_CLIENT = Azure::GraphRbac::Profiles::Latest::Client
-      client = connection.azure_client(GRAPH_API_CLIENT)
-      client.class.must_equal GRAPH_API_CLIENT
-    end
-
-    it 'can use azure_client vault client' do
-      VAULT_API_CLIENT = ::Azure::KeyVault::Profiles::Latest::Mgmt::Client
-      client = connection.azure_client(VAULT_API_CLIENT, vault_name: 'Test Vault')
-      client.class.must_equal VAULT_API_CLIENT
-    end
-
-    it 'cannot instantiate azure_client vault client without a vault name' do
-      VAULT_API_CLIENT = ::Azure::KeyVault::Profiles::Latest::Mgmt::Client
-      assert_raises(Train::UserError) do
-        connection.azure_client(VAULT_API_CLIENT)
-      end
-    end
-  end
-
-  describe 'connect' do
-    it 'validate credentials' do
-      connection.connect
-      token = credentials[:credentials].instance_variable_get(:@token_provider)
-      token.class.must_equal MsRestAzure::ApplicationTokenProvider
-
-      credentials[:credentials].class.must_equal MsRest::TokenCredentials
-      credentials[:tenant_id].must_equal 'test_tenant_id'
-      credentials[:client_id].must_equal 'test_client_id'
-      credentials[:client_secret].must_equal 'test_client_secret'
-      credentials[:subscription_id].must_equal 'test_subscription_id'
-    end
-
-    it 'validate msi credentials' do
-      options[:client_id] = nil
-      options[:client_secret] = nil
-      Train::Transports::Azure::Connection.any_instance.stubs(:port_open?).returns(true)
-
-      connection.connect
-      token = credentials[:credentials].instance_variable_get(:@token_provider)
-      token.class.must_equal MsRestAzure::MSITokenProvider
-
-      credentials[:credentials].class.must_equal MsRest::TokenCredentials
-      credentials[:tenant_id].must_equal 'test_tenant_id'
-      credentials[:subscription_id].must_equal 'test_subscription_id'
-      credentials[:client_id].must_be_nil
-      credentials[:client_secret].must_be_nil
-      options[:msi_port].must_equal 50342
-    end
-  end
-
-  describe 'unique_identifier' do
-    it 'returns a subscription id' do
-      connection.unique_identifier.must_equal 'test_subscription_id'
-    end
-
-    it 'returns a tenant id' do
-      options = connection.instance_variable_get(:@options)
-      options[:subscription_id] = nil
-      connection.unique_identifier.must_equal 'test_tenant_id'
-    end
-  end
-end