vagrant-unbundled 2.1.4.0 → 2.2.0.0

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/integration/spec_helper.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'winrm'
+require 'json'
+require_relative '../matchers'
+
+# Creates a WinRM connection for integration tests
+module ConnectionHelper
+  def winrm_connection
+    WinRM::Connection.new(connection_opts)
+  end
+
+  def connection_opts
+    @connection_opts ||= begin
+      cfg = symbolize_keys(YAML.safe_load(File.read(winrm_config_path)))
+      merge_environment(cfg)
+    end
+  end
+
+  def merge_environment(config)
+    merge_config_option_from_environment(config, 'user')
+    merge_config_option_from_environment(config, 'password')
+    merge_config_option_from_environment(config, 'no_ssl_peer_verification')
+    config[:ssl_peer_fingerprint] = ENV['winrm_cert'] if ENV['use_ssl_peer_fingerprint']
+    config[:endpoint] = ENV['winrm_endpoint'] if ENV['winrm_endpoint']
+    config
+  end
+
+  def merge_config_option_from_environment(config, key)
+    env_key = 'winrm_' + key
+    config[key.to_sym] = ENV[env_key] if ENV[env_key]
+  end
+
+  def winrm_config_path
+    # Copy config-example.yml to config.yml and edit for your local ConnectionOpts
+    path = File.expand_path("#{File.dirname(__FILE__)}/config.yml")
+    unless File.exist?(path)
+      # user hasn't done this, so use sane defaults for unit tests
+      path = File.expand_path("#{File.dirname(__FILE__)}/config-example.yml")
+    end
+    path
+  end
+
+  def symbolize_keys(hash)
+    hash.each_with_object({}) do |(key, value), result|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  else value
+                  end
+      result[new_key] = new_value
+      result
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include(ConnectionHelper)
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/integration/transport_spec.rb

@@ -0,0 +1,98 @@
+require_relative 'spec_helper'
+
+describe 'WinRM connection' do
+  let(:connection) do
+    endpoint = connection_opts[:endpoint].dup
+    if auth_type == :ssl
+      endpoint.sub!('5985', '5986')
+      endpoint.sub!('http', 'https')
+    end
+    conn_options = {
+      transport: auth_type,
+      endpoint: endpoint
+    }.merge(options)
+    WinRM::Connection.new(conn_options).shell(:cmd)
+  end
+  let(:options) do
+    opts = {}
+    opts[:user] = connection_opts[:user]
+    opts[:password] = connection_opts[:password]
+    opts[:basic_auth_only] = basic_auth_only
+    opts[:no_ssl_peer_verification] = no_ssl_peer_verification
+    opts[:ssl_peer_fingerprint] = ssl_peer_fingerprint
+    opts[:client_cert] = user_cert
+    opts[:client_key] = user_key
+    opts
+  end
+  let(:basic_auth_only) { false }
+  let(:no_ssl_peer_verification) { false }
+  let(:ssl_peer_fingerprint) { nil }
+  let(:user_cert) { nil }
+  let(:user_key) { nil }
+
+  subject(:output) { connection.run('ipconfig') }
+
+  after(:each) do
+    connection.close
+  end
+
+  shared_examples 'a valid_connection' do
+    it 'has a 0 exit code' do
+      expect(subject).to have_exit_code 0
+    end
+
+    it 'includes command output' do
+      expect(subject).to have_stdout_match(/Windows IP Configuration/)
+    end
+
+    it 'has no errors' do
+      expect(subject).to have_no_stderr
+    end
+  end
+
+  context 'HttpPlaintext' do
+    let(:basic_auth_only) { true }
+    let(:auth_type) { :plaintext }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'HttpNegotiate' do
+    let(:auth_type) { :negotiate }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'BasicAuthSSL', skip: ENV['winrm_cert'].nil? do
+    let(:basic_auth_only) { true }
+    let(:auth_type) { :ssl }
+    let(:no_ssl_peer_verification) { true }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'ClientCertAuthSSL', skip: ENV['user_cert'].nil? do
+    let(:auth_type) { :ssl }
+    let(:no_ssl_peer_verification) { true }
+    let(:user_cert) { ENV['user_cert'] }
+    let(:user_key) { ENV['user_key'] }
+
+    before { options[:pass] = nil }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'Negotiate over SSL', skip: ENV['winrm_cert'].nil? do
+    let(:auth_type) { :ssl }
+    let(:no_ssl_peer_verification) { true }
+
+    it_behaves_like 'a valid_connection'
+  end
+
+  context 'SSL fingerprint', skip: ENV['winrm_cert'].nil? do
+    let(:auth_type) { :ssl }
+    let(:ssl_peer_fingerprint) { ENV['winrm_cert'] }
+
+    it_behaves_like 'a valid_connection'
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/integration/wql_spec.rb

@@ -0,0 +1,33 @@
+require_relative 'spec_helper'
+
+describe 'winrm client wql' do
+  before(:all) do
+    @winrm = winrm_connection
+  end
+
+  it 'should query Win32_OperatingSystem' do
+    output = @winrm.run_wql('select * from Win32_OperatingSystem')
+    expect(output).to_not be_empty
+    output_caption = output[:win32_operating_system][0][:caption]
+    expect(output_caption).to include('Microsoft')
+    expect(output_caption).to include('Windows')
+  end
+
+  it 'should query Win32_Process' do
+    output = @winrm.run_wql('select * from Win32_Process')
+    expect(output).to_not be_empty
+    process_count = output[:win32_process].count
+    expect(process_count).to be > 1
+    expect(output[:win32_process]).to all(include(:command_line))
+  end
+
+  it 'should query Win32_Process with block' do
+    count = 0
+    @winrm.run_wql('select * from Win32_Process') do |type, item|
+      expect(type).to eq(:win32_process)
+      expect(item).to include(:command_line)
+      count += 1
+    end
+    expect(count).to be > 1
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/matchers.rb

@@ -0,0 +1,59 @@
+require 'rspec/expectations'
+
+# rspec matchers
+RSpec::Matchers.define :have_stdout_match do |expected_stdout|
+  match do |actual_output|
+    !expected_stdout.match(actual_output.stdout).nil?
+  end
+  failure_message do |actual_output|
+    "expected that '#{actual_output.stdout}' would match #{expected_stdout}"
+  end
+end
+
+RSpec::Matchers.define :have_stderr_match do |expected_stderr|
+  match do |actual_output|
+    !expected_stderr.match(actual_output.stderr).nil?
+  end
+  failure_message do |actual_output|
+    "expected that '#{actual_output.stderr}' would match #{expected_stderr}"
+  end
+end
+
+RSpec::Matchers.define :have_no_stdout do
+  match do |actual_output|
+    stdout = actual_output.stdout
+    ['\r\n', ''].include?(stdout)
+  end
+  failure_message do |actual_output|
+    "expected that '#{actual_output.stdout}' would have no stdout"
+  end
+end
+
+RSpec::Matchers.define :have_no_stderr do
+  match do |actual_output|
+    stderr = actual_output.stderr
+    ['\r\n', ''].include?(stderr)
+  end
+  failure_message do |actual_output|
+    "expected that '#{actual_output.stderr}' would have no stderr"
+  end
+end
+
+RSpec::Matchers.define :have_exit_code do |expected_exit_code|
+  match do |actual_output|
+    expected_exit_code == actual_output.exitcode
+  end
+  failure_message do |actual_output|
+    "expected exit code #{expected_exit_code}, but got #{actual_output.exitcode}"
+  end
+end
+
+RSpec::Matchers.define :be_a_uid do
+  match do |actual|
+    # WinRM1.1 returns uuid's prefixed with 'uuid:' where as later versions do not
+    actual && actual.to_s.match(/^(uuid:)*\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$/)
+  end
+  failure_message do |actual|
+    "expected a uid, but got '#{actual}'"
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/configuration_spec.rb

@@ -0,0 +1,183 @@
+require 'winrm/connection_opts'
+
+describe WinRM::ConnectionOpts do
+  shared_examples 'invalid options' do
+    it 'throws a validation error' do
+      expect { WinRM::ConnectionOpts.create_with_defaults(overrides) }.to raise_error
+    end
+  end
+
+  context 'when there are no overrides' do
+    it_behaves_like 'invalid options'
+  end
+
+  context 'when there are only username and password' do
+    let(:overrides) do
+      {
+        user: 'Administrator',
+        password: 'password'
+      }
+    end
+
+    it_behaves_like 'invalid options'
+  end
+
+  context 'when there are only username and endpoint' do
+    let(:overrides) do
+      {
+        user: 'Administrator',
+        endpoint: 'http://localhost:5985/wsman'
+      }
+    end
+
+    it_behaves_like 'invalid options'
+  end
+
+  context 'when there are only password and endpoint' do
+    let(:overrides) do
+      {
+        password: 'password',
+        endpoint: 'http://localhost:5985/wsman'
+      }
+    end
+
+    it_behaves_like 'invalid options'
+  end
+
+  context 'when there are only certificate and key' do
+    let(:overrides) do
+      {
+        client_cert: 'path/to/cert',
+        client_key: 'path/to/key'
+      }
+    end
+
+    it_behaves_like 'invalid options'
+  end
+
+  context 'when there are only certificate and endpoint' do
+    let(:overrides) do
+      {
+        client_cert: 'path/to/cert',
+        endpoint: 'http://localhost:5985/wsman'
+      }
+    end
+
+    it_behaves_like 'invalid options'
+  end
+
+  context 'when there are only key and endpoint' do
+    let(:overrides) do
+      {
+        client_key: 'path/to/key',
+        endpoint: 'http://localhost:5985/wsman'
+      }
+    end
+
+    it_behaves_like 'invalid options'
+  end
+
+  context 'when username, password, and endpoint are given' do
+    let(:overrides) do
+      {
+        user: 'Administrator',
+        password: 'password',
+        endpoint: 'http://localhost:5985/wsman'
+      }
+    end
+    describe '#create_with_defaults' do
+      it 'creates a ConnectionOpts object' do
+        config = WinRM::ConnectionOpts.create_with_defaults(overrides)
+        expect(config[:user]).to eq(overrides[:user])
+        expect(config[:password]).to eq(overrides[:password])
+        expect(config[:endpoint]).to eq(overrides[:endpoint])
+      end
+    end
+  end
+
+  context 'when certificate, key and endpoint are given' do
+    let(:overrides) do
+      {
+        client_cert: 'path/to/cert',
+        client_key: 'path/to/key',
+        endpoint: 'http://localhost:5985/wsman'
+      }
+    end
+    describe '#create_with_defaults' do
+      it 'creates a ConnectionOpts object' do
+        config = WinRM::ConnectionOpts.create_with_defaults(overrides)
+        expect(config[:client_cert]).to eq(overrides[:client_cert])
+        expect(config[:client_key]).to eq(overrides[:client_key])
+        expect(config[:endpoint]).to eq(overrides[:endpoint])
+      end
+    end
+  end
+
+  context 'when overrides are provided' do
+    let(:overrides) do
+      {
+        user: 'Administrator',
+        password: 'password',
+        endpoint: 'http://localhost:5985/wsman',
+        transport: :ssl
+      }
+    end
+    describe '#create_with_defaults' do
+      it 'creates a ConnectionOpts object with overrides' do
+        config = WinRM::ConnectionOpts.create_with_defaults(overrides)
+        expect(config[:transport]).to eq(overrides[:transport])
+      end
+    end
+  end
+
+  context 'when receive_timeout is specified' do
+    let(:overrides) do
+      {
+        user: 'Administrator',
+        password: 'password',
+        endpoint: 'http://localhost:5985/wsman',
+        receive_timeout: 120
+      }
+    end
+    describe '#create_with_defaults' do
+      it 'creates a ConnectionOpts object with the correct receive_timeout' do
+        config = WinRM::ConnectionOpts.create_with_defaults(overrides)
+        expect(config[:receive_timeout]).to eq(overrides[:receive_timeout])
+      end
+    end
+  end
+
+  context 'when operation_timeout is specified' do
+    let(:overrides) do
+      {
+        user: 'Administrator',
+        password: 'password',
+        endpoint: 'http://localhost:5985/wsman',
+        operation_timeout: 120
+      }
+    end
+    describe '#create_with_defaults' do
+      it 'creates a ConnectionOpts object with the correct timeouts' do
+        config = WinRM::ConnectionOpts.create_with_defaults(overrides)
+        expect(config[:operation_timeout]).to eq(overrides[:operation_timeout])
+        expect(config[:receive_timeout]).to eq(overrides[:operation_timeout] + 10)
+      end
+    end
+  end
+
+  context 'when invalid data types are given' do
+    let(:overrides) do
+      {
+        user: 'Administrator',
+        password: 'password',
+        endpoint: 'http://localhost:5985/wsman',
+        operation_timeout: 'PT60S'
+      }
+    end
+    describe '#create_with_defaults' do
+      it 'raises an error' do
+        expect { WinRM::ConnectionOpts.create_with_defaults(overrides) }.to raise_error
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/connection_spec.rb

@@ -0,0 +1,37 @@
+require 'winrm'
+require 'winrm/shells/cmd'
+require 'winrm/shells/power_shell'
+
+describe WinRM::Connection do
+  context 'new' do
+    it 'creates a new winrm session' do
+      connection = WinRM::Connection.new(default_connection_opts)
+      expect(connection).not_to be_nil
+    end
+  end
+
+  context 'shell(:cmd)' do
+    it 'creates a new cmd session' do
+      connection = WinRM::Connection.new(default_connection_opts)
+      cmd_shell = connection.shell(:cmd)
+      expect(cmd_shell).not_to be_nil
+      expect(cmd_shell).to be_an_instance_of(WinRM::Shells::Cmd)
+    end
+  end
+
+  context 'shell(:powershell)' do
+    it 'creates a new powershell session' do
+      connection = WinRM::Connection.new(default_connection_opts)
+      cmd_shell = connection.shell(:powershell)
+      expect(cmd_shell).not_to be_nil
+      expect(cmd_shell).to be_an_instance_of(WinRM::Shells::Powershell)
+    end
+  end
+
+  context 'shell(:not_a_real_shell_type)' do
+    it 'raises a descriptive error' do
+      connection = WinRM::Connection.new(default_connection_opts)
+      expect { connection.shell(:not_a_real_shell_type) }.to raise_error(WinRM::InvalidShellError)
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/exception_spec.rb

@@ -0,0 +1,49 @@
+describe 'Exceptions' do
+  describe WinRM::WinRMAuthorizationError do
+    let(:error) { WinRM::WinRMHTTPTransportError.new('Foo happened', 500) }
+
+    it 'adds the response code to the message' do
+      expect(error.message).to eq('Foo happened (500).')
+    end
+
+    it 'exposes the response code as an attribute' do
+      expect(error.status_code).to eq 500
+    end
+
+    it 'is a winrm error' do
+      expect(error).to be_kind_of(WinRM::WinRMError)
+    end
+  end
+
+  describe WinRM::WinRMWSManFault do
+    let(:error) { WinRM::WinRMWSManFault.new('fault text', 42) }
+
+    it 'exposes the fault text as an attribute' do
+      expect(error.fault_description).to eq('fault text')
+    end
+
+    it 'exposes the fault code as an attribute' do
+      expect(error.fault_code).to eq 42
+    end
+
+    it 'is a winrm error' do
+      expect(error).to be_kind_of(WinRM::WinRMError)
+    end
+  end
+
+  describe WinRM::WinRMWMIError do
+    let(:error) { WinRM::WinRMWMIError.new('message text', 77_777) }
+
+    it 'exposes the error text as an attribute' do
+      expect(error.error).to eq('message text')
+    end
+
+    it 'exposes the error code as an attribute' do
+      expect(error.error_code).to eq 77_777
+    end
+
+    it 'is a winrm error' do
+      expect(error).to be_kind_of(WinRM::WinRMError)
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/http/transport_factory_spec.rb

@@ -0,0 +1,66 @@
+require 'winrm/exceptions'
+require 'winrm/http/transport_factory'
+
+module WinRM
+  module HTTP
+    # Remove the gssapi stuff in kerberos init for tests
+    class HttpGSSAPI < HttpTransport
+      def initialize(endpoint, realm, opts, service = nil) end
+    end
+  end
+end
+
+describe WinRM::HTTP::TransportFactory do
+  describe '#create_transport' do
+    let(:transport) { :negotiate }
+    let(:options) do
+      {
+        transport: transport,
+        endpoint: 'endpoint',
+        user: 'user'
+      }
+    end
+
+    it 'creates a negotiate transport' do
+      options[:transport] = :negotiate
+      expect(subject.create_transport(options)).to be_a(WinRM::HTTP::HttpNegotiate)
+    end
+
+    it 'creates a plaintext transport' do
+      options[:transport] = :plaintext
+      expect(subject.create_transport(options)).to be_a(WinRM::HTTP::HttpPlaintext)
+    end
+
+    it 'creates a basic auth ssl transport' do
+      options[:transport] = :ssl
+      options[:basic_auth_only] = true
+      expect(subject.create_transport(options)).to be_a(WinRM::HTTP::BasicAuthSSL)
+    end
+
+    it 'creates a client cert ssl transport' do
+      options[:transport] = :ssl
+      options[:client_cert] = 'cert'
+      expect(subject.create_transport(options)).to be_a(WinRM::HTTP::ClientCertAuthSSL)
+    end
+
+    it 'creates a negotiate over ssl transport' do
+      options[:transport] = :ssl
+      expect(subject.create_transport(options)).to be_a(WinRM::HTTP::HttpNegotiate)
+    end
+
+    it 'creates a kerberos transport' do
+      options[:transport] = :kerberos
+      expect(subject.create_transport(options)).to be_a(WinRM::HTTP::HttpGSSAPI)
+    end
+
+    it 'creates a transport from a stringified transport' do
+      options[:transport] = 'negotiate'
+      expect(subject.create_transport(options)).to be_a(WinRM::HTTP::HttpNegotiate)
+    end
+
+    it 'raises when transport type does not exist' do
+      options[:transport] = :fancy
+      expect { subject.create_transport(options) }.to raise_error(WinRM::InvalidTransportError)
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/winrm-2.3.0/tests/spec/http/transport_spec.rb

@@ -0,0 +1,43 @@
+require 'rubyntlm'
+require 'winrm/http/transport'
+
+describe WinRM::HTTP::HttpNegotiate do
+  describe '#init' do
+    let(:endpoint) { 'some_endpoint' }
+    let(:domain) { 'some_domain' }
+    let(:user) { 'some_user' }
+    let(:password) { 'some_password' }
+    let(:options) { {} }
+
+    context 'user is not domain prefixed' do
+      it 'does not pass a domain to the NTLM client' do
+        expect(Net::NTLM::Client).to receive(:new).with(user, password, options)
+        WinRM::HTTP::HttpNegotiate.new(endpoint, user, password, options)
+      end
+    end
+
+    context 'user is domain prefixed' do
+      it 'passes prefixed domain to the NTLM client' do
+        expect(Net::NTLM::Client).to receive(:new) do |passed_user, passed_password, passed_options|
+          expect(passed_user).to eq user
+          expect(passed_password).to eq password
+          expect(passed_options[:domain]).to eq domain
+        end
+        WinRM::HTTP::HttpNegotiate.new(endpoint, "#{domain}\\#{user}", password, options)
+      end
+    end
+
+    context 'option is passed with a domain' do
+      let(:options) { { domain: domain } }
+
+      it 'passes domain option to the NTLM client' do
+        expect(Net::NTLM::Client).to receive(:new) do |passed_user, passed_password, passed_options|
+          expect(passed_user).to eq user
+          expect(passed_password).to eq password
+          expect(passed_options[:domain]).to eq domain
+        end
+        WinRM::HTTP::HttpNegotiate.new(endpoint, user, password, options)
+      end
+    end
+  end
+end