winrm 2.2.3 → 2.3.6

data/tests/spec/configuration_spec.rb

@@ -1,184 +0,0 @@
-# encoding: UTF-8
-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/tests/spec/connection_spec.rb

@@ -1,39 +0,0 @@
-# encoding: UTF-8
-
-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/tests/spec/exception_spec.rb

@@ -1,50 +0,0 @@
-# encoding: UTF-8
-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/tests/spec/http/transport_factory_spec.rb

@@ -1,68 +0,0 @@
-# encoding: UTF-8
-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/tests/spec/http/transport_spec.rb

@@ -1,44 +0,0 @@
-# encoding: UTF-8
-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

data/tests/spec/output_spec.rb

@@ -1,127 +0,0 @@
-# encoding: UTF-8
-describe WinRM::Output do
-  subject { WinRM::Output.new }
-
-  context 'when there is no output' do
-    describe '#stdout' do
-      it 'is empty' do
-        expect(subject.stdout).to be_empty
-      end
-    end
-
-    describe '#stderr' do
-      it 'is empty' do
-        expect(subject.stderr).to be_empty
-      end
-    end
-
-    describe '#output' do
-      it 'is empty' do
-        expect(subject.output).to be_empty
-      end
-    end
-  end
-
-  context 'when there is only one line' do
-    describe '#stdout' do
-      it 'is equal to that line' do
-        subject << { stdout: 'foo' }
-        expect(subject.stdout).to eq('foo')
-      end
-    end
-
-    describe '#stderr' do
-      it 'is equal to that line' do
-        subject << { stderr: 'foo' }
-        expect(subject.stderr).to eq('foo')
-      end
-    end
-
-    describe '#output' do
-      it 'is equal to stdout' do
-        subject << { stdout: 'foo' }
-        expect(subject.output).to eq('foo')
-      end
-
-      it 'is equal to stderr' do
-        subject << { stderr: 'foo' }
-        expect(subject.output).to eq('foo')
-      end
-    end
-  end
-
-  context 'when there is one line of each type' do
-    before(:each) do
-      subject << { stdout: 'foo' }
-      subject << { stderr: 'bar' }
-    end
-
-    describe '#stdout' do
-      it 'is equal to that line' do
-        expect(subject.stdout).to eq('foo')
-      end
-    end
-
-    describe '#stderr' do
-      it 'is equal to that line' do
-        expect(subject.stderr).to eq('bar')
-      end
-    end
-
-    describe '#output' do
-      it 'is equal to stdout + stderr' do
-        expect(subject.output).to eq('foobar')
-      end
-    end
-  end
-
-  context 'when there are multiple lines' do
-    before(:each) do
-      subject << { stdout: 'I can have a newline\nanywhere, ' }
-      subject << { stderr: 'I can also have stderr' }
-      subject << { stdout: 'or stdout', stderr: ' and stderr' }
-      subject << {}
-      subject << { stdout: ' or nothing! (above)' }
-    end
-
-    describe '#stdout' do
-      it 'is equal to that line' do
-        expect(subject.stdout).to eq(
-          'I can have a newline\nanywhere, or stdout or nothing! (above)')
-      end
-    end
-
-    describe '#stderr' do
-      it 'is equal to that line' do
-        expect(subject.stderr).to eq('I can also have stderr and stderr')
-      end
-    end
-
-    describe '#output' do
-      it 'is equal to stdout + stderr' do
-        expect(subject.output).to eq(
-          'I can have a newline\nanywhere, I can also have stderror stdout ' \
-            'and stderr or nothing! (above)')
-      end
-    end
-  end
-
-  describe '#exitcode' do
-    let(:exitcode) { 0 }
-
-    context 'when a valid exit code is set' do
-      it 'sets the exit code' do
-        subject.exitcode = exitcode
-        expect(subject.exitcode).to eq exitcode
-      end
-    end
-
-    context 'when an invalid exit code is set' do
-      let(:exitcode) { 'bad' }
-
-      it 'sets the exit code' do
-        expect { subject.exitcode = exitcode }.to raise_error WinRM::InvalidExitCode
-      end
-    end
-  end
-end

data/tests/spec/psrp/fragment_spec.rb

@@ -1,62 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/fragment'
-
-describe WinRM::PSRP::Fragment do
-  let(:id) { 1 }
-  let(:message) { 'blah blah blah' }
-
-  context 'called with just id and blob' do
-    subject { described_class.new(id, message.bytes) }
-
-    it 'sets the message id to 1' do
-      expect(subject.bytes[0..7]).to eq([0, 0, 0, 0, 0, 0, 0, id])
-    end
-    it 'sets the fragment id to 0' do
-      expect(subject.bytes[8..15]).to eq([0, 0, 0, 0, 0, 0, 0, 0])
-    end
-    it 'sets the last 2 bits of the end/start fragment' do
-      expect(subject.bytes[16]).to eq(3)
-    end
-    it 'sets message blob length to 3640' do
-      expect(subject.bytes[17..20]).to eq([0, 0, 0, message.bytes.length])
-    end
-    it 'sets message blob' do
-      expect(subject.bytes[21..-1]).to eq(message.bytes)
-    end
-  end
-
-  context 'specifying a fragment id' do
-    let(:fragment_id) { 1 }
-
-    subject { described_class.new(id, message.bytes, fragment_id) }
-
-    it 'sets the fragment id' do
-      expect(subject.bytes[8..15]).to eq([0, 0, 0, 0, 0, 0, 0, fragment_id])
-    end
-  end
-
-  context 'middle fragment' do
-    subject { described_class.new(id, message.bytes, 1, false, false) }
-
-    it 'sets the last 2 bits of the end/start fragment to 0' do
-      expect(subject.bytes[16]).to eq(0)
-    end
-  end
-
-  context 'end fragment' do
-    subject { described_class.new(id, message.bytes, 1, true, false) }
-
-    it 'sets the end fragment bit' do
-      expect(subject.bytes[16]).to eq(1)
-    end
-  end
-
-  context 'start fragment' do
-    subject { described_class.new(id, message.bytes, 1, false, true) }
-
-    it 'sets the start fragment bit' do
-      expect(subject.bytes[16]).to eq(2)
-    end
-  end
-end

data/tests/spec/psrp/message_data/base_spec.rb

@@ -1,13 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/message_data/base'
-
-describe WinRM::PSRP::MessageData::Base do
-  let(:raw_data) { 'raw_data' }
-
-  subject { WinRM::PSRP::MessageData::Base.new(raw_data) }
-
-  it 'holds raw message data' do
-    expect(subject.raw).to eq(raw_data)
-  end
-end

data/tests/spec/psrp/message_data/error_record_spec.rb

@@ -1,41 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/message_data/base'
-require 'winrm/psrp/message_data/error_record'
-
-describe WinRM::PSRP::MessageData::ErrorRecord do
-  let(:test_data_xml_template) do
-    ERB.new(stubbed_clixml('error_record.xml.erb'))
-  end
-  let(:error_message) { 'an error' }
-  let(:script_root) { 'script_root' }
-  let(:category_message) { 'category message' }
-  let(:stack_trace) { 'stack trace' }
-  let(:error_id) { 'Microsoft.PowerShell.Commands.WriteErrorException' }
-  let(:raw_data) { test_data_xml_template.result(binding) }
-  subject { described_class.new(raw_data) }
-
-  it 'returns the exception' do
-    expect(subject.exception[:message]).to eq(error_message)
-  end
-
-  it 'returns the FullyQualifiedErrorId' do
-    expect(subject.fully_qualified_error_id).to eq(error_id)
-  end
-
-  it 'returns the invocation info' do
-    expect(subject.invocation_info[:line]).to eq("write-error '#{error_message}'")
-  end
-
-  it 'converts camel case properties to underscore' do
-    expect(subject.invocation_info[:ps_script_root]).to eq(script_root)
-  end
-
-  it 'returns the error category message' do
-    expect(subject.error_category_message).to eq(category_message)
-  end
-
-  it 'returns the script stack trace' do
-    expect(subject.error_details_script_stack_trace).to eq(stack_trace)
-  end
-end

data/tests/spec/psrp/message_data/pipeline_host_call_spec.rb

@@ -1,25 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/message_data/base'
-require 'winrm/psrp/message_data/pipeline_host_call'
-
-describe WinRM::PSRP::MessageData::PipelineHostCall do
-  let(:raw_data) do
-    "\xEF\xBB\xBF<Obj RefId=\"0\"><MS><I64 N=\"ci\">-100</I64><Obj N=\"mi\" RefId=\"1\">"\
-    '<TN RefId="0"><T>System.Management.Automation.Remoting.RemoteHostMethodId</T>'\
-    '<T>System.Enum</T><T>System.ValueType</T><T>System.Object</T></TN>'\
-    '<ToString>WriteLine3</ToString><I32>17</I32></Obj><Obj N="mp" RefId="2">'\
-    '<TN RefId="1"><T>System.Collections.ArrayList</T><T>System.Object</T></TN><LST>'\
-    '<I32>7</I32><I32>0</I32><S>hello</S></LST></Obj></MS></Obj>'
-  end
-
-  subject { described_class.new(raw_data) }
-
-  it 'parses method identifier' do
-    expect(subject.method_identifier).to eq('WriteLine3')
-  end
-
-  it 'parses method parameters' do
-    expect(subject.method_parameters[:s]).to eq('hello')
-  end
-end

data/tests/spec/psrp/message_data/pipeline_output_spec.rb

@@ -1,32 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/psrp/message_data/base'
-require 'winrm/psrp/message_data/pipeline_output'
-
-describe WinRM::PSRP::MessageData::PipelineOutput do
-  subject { described_class.new(raw_data) }
-
-  context 'receiving output with BOM and no new line' do
-    let(:raw_data) { "\xEF\xBB\xBF<obj><S>some data</S></obj>" }
-
-    it 'output removes BOM and adds newline' do
-      expect(subject.output).to eq("some data\r\n")
-    end
-  end
-
-  context 'receiving output with encoded new line' do
-    let(:raw_data) { '<obj><S>some data_x000D__x000A_</S></obj>' }
-
-    it 'decodes without double newline' do
-      expect(subject.output).to eq("some data\r\n")
-    end
-  end
-
-  context 'receiving output with new line in middle' do
-    let(:raw_data) { '<obj><S>some_x000D__x000A_data</S></obj>' }
-
-    it 'decodes and replaces newline' do
-      expect(subject.output).to eq("some\r\ndata\r\n")
-    end
-  end
-end