winrm 2.1.0 → 2.1.1

data/tests/spec/http/transport_factory_spec.rb

@@ -1,68 +1,68 @@
-# 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
+# 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 +1,44 @@
-# 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
+# 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 +1,127 @@
-# 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
+# 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