winrm 2.2.3 → 2.3.6

data/tests/spec/response_handler_spec.rb

@@ -1,61 +0,0 @@
-# encoding: UTF-8
-require 'winrm/http/response_handler'
-
-describe 'response handler', unit: true do
-  %w(v1 v2).each do |winrm_version|
-    context "winrm_version #{winrm_version}" do
-      let(:soap_fault) { stubbed_response("soap_fault_#{winrm_version}.xml") }
-      let(:open_shell) { stubbed_response("open_shell_#{winrm_version}.xml") }
-
-      describe "successful 200 #{winrm_version} response" do
-        it 'returns an xml doc' do
-          handler = WinRM::ResponseHandler.new(open_shell, 200)
-          xml_doc = handler.parse_to_xml
-          expect(xml_doc).to be_instance_of(REXML::Document)
-          expect(xml_doc.to_s).to eq(REXML::Document.new(open_shell).to_s)
-        end
-      end
-
-      describe "failed 500 #{winrm_version} response" do
-        it 'raises a WinRMHTTPTransportError' do
-          handler = WinRM::ResponseHandler.new('', 500)
-          expect { handler.parse_to_xml }.to raise_error(WinRM::WinRMHTTPTransportError)
-        end
-      end
-
-      describe "failed 401 #{winrm_version} response" do
-        it 'raises a WinRMAuthorizationError' do
-          handler = WinRM::ResponseHandler.new('', 401)
-          expect { handler.parse_to_xml }.to raise_error(WinRM::WinRMAuthorizationError)
-        end
-      end
-
-      describe "failed 400 #{winrm_version} response" do
-        it 'raises a WinRMWSManFault' do
-          handler = WinRM::ResponseHandler.new(soap_fault, 400)
-          begin
-            handler.parse_to_xml
-          rescue WinRM::WinRMWSManFault => e
-            expect(e.fault_code).to eq('2150858778')
-            expect(e.fault_description).to include(
-              'The specified class does not exist in the given namespace')
-          end
-        end
-      end
-    end
-  end
-
-  describe 'failed 500 WMI error response' do
-    let(:wmi_error) { stubbed_response('wmi_error_v2.xml') }
-
-    it 'raises a WinRMWMIError' do
-      handler = WinRM::ResponseHandler.new(wmi_error, 500)
-      begin
-        handler.parse_to_xml
-      rescue WinRM::WinRMWMIError => e
-        expect(e.error_code).to eq('2150859173')
-        expect(e.error).to include('The WS-Management service cannot process the request.')
-      end
-    end
-  end
-end

data/tests/spec/shells/base_spec.rb

@@ -1,225 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/shells/base'
-
-# Dummy shell class
-class DummyShell < WinRM::Shells::Base
-  class << self
-    def finalize(connection_opts, transport, shell_id)
-      proc { DummyShell.close_shell(connection_opts, transport, shell_id) }
-    end
-
-    def close_shell(_connection_opts, _transport, _shell_id)
-      @closed = true
-    end
-
-    def closed?
-      @closed
-    end
-  end
-
-  def open_shell
-    @closed = false
-    'shell_id'
-  end
-
-  def send_command(_command, _arguments)
-    'command_id'
-  end
-
-  def out_streams
-    %w(std)
-  end
-end
-
-describe DummyShell do
-  let(:retry_limit) { 1 }
-  let(:shell_id) { 'shell_id' }
-  let(:output) { 'output' }
-  let(:command_id) { 'command_id' }
-  let(:payload) { 'message_payload' }
-  let(:command) { 'command' }
-  let(:arguments) { ['args'] }
-  let(:output_message) { double('output_message', build: 'output_message') }
-  let(:connection_options) { { max_commands: 100, retry_limit: retry_limit, retry_delay: 0 } }
-  let(:transport) { double('transport') }
-  let(:reader) { double('reader') }
-
-  before do
-    allow(subject).to receive(:response_reader).and_return(reader)
-    allow(subject).to receive(:command_output_message).with(shell_id, command_id)
-      .and_return(output_message)
-    allow(reader).to receive(:read_output).with(output_message).and_return(output)
-    allow(transport).to receive(:send_request)
-  end
-
-  subject { described_class.new(connection_options, transport, Logging.logger['test']) }
-
-  shared_examples 'retry shell command' do
-    it 'only closes the shell if there are too many' do
-      if fault == WinRM::Shells::Base::TOO_MANY_COMMANDS
-        expect(DummyShell).to receive(:close_shell)
-      else
-        expect(DummyShell).not_to receive(:close_shell)
-      end
-
-      subject.run(command, arguments)
-    end
-
-    it 'opens a new shell' do
-      expect(subject).to receive(:open).and_call_original.twice
-
-      subject.run(command, arguments)
-    end
-
-    it 'retries the command once' do
-      expect(subject).to receive(:send_command).twice
-
-      subject.run(command, arguments)
-    end
-  end
-
-  describe '#run' do
-    it 'opens a shell' do
-      subject.run(command, arguments)
-      expect(subject.shell_id).not_to be nil
-    end
-
-    it 'returns output from generated command' do
-      expect(subject.run(command, arguments)).to eq output
-    end
-
-    it 'sends cleanup message through transport' do
-      allow(SecureRandom).to receive(:uuid).and_return('uuid')
-      expect(transport).to receive(:send_request)
-        .with(
-          WinRM::WSMV::CleanupCommand.new(
-            connection_options,
-            shell_uri: nil,
-            shell_id: shell_id,
-            command_id: command_id
-          ).build
-        )
-      subject.run(command, arguments)
-    end
-
-    it 'does not error if cleanup is aborted' do
-      allow(SecureRandom).to receive(:uuid).and_return('uuid')
-      expect(transport).to receive(:send_request)
-        .with(
-          WinRM::WSMV::CleanupCommand.new(
-            connection_options,
-            shell_uri: nil,
-            shell_id: shell_id,
-            command_id: command_id
-          ).build
-        ).and_raise(WinRM::WinRMWSManFault.new('oops', '995'))
-      subject.run(command, arguments)
-    end
-
-    it 'does not error if shell is not present anymore' do
-      allow(SecureRandom).to receive(:uuid).and_return('uuid')
-      expect(transport).to receive(:send_request)
-        .with(
-          WinRM::WSMV::CleanupCommand.new(
-            connection_options,
-            shell_uri: nil,
-            shell_id: shell_id,
-            command_id: command_id
-          ).build
-        ).and_raise(WinRM::WinRMWSManFault.new('oops', '2150858843'))
-      subject.run(command, arguments)
-    end
-
-    it 'opens a shell only once when shell is already open' do
-      expect(subject).to receive(:open_shell).and_call_original.once
-      subject.run(command, arguments)
-      subject.run(command, arguments)
-    end
-
-    describe 'connection resets' do
-      before do
-        @times_called = 0
-
-        allow(subject).to receive(:send_command) do
-          @times_called += 1
-          raise WinRM::WinRMWSManFault.new('oops', fault) if @times_called == 1
-          command_id
-        end
-      end
-
-      context 'when shell is closed on server' do
-        let(:fault) { '2150858843' }
-
-        include_examples 'retry shell command'
-      end
-
-      context 'when shell accesses a deleted registry key' do
-        let(:fault) { '2147943418' }
-
-        include_examples 'retry shell command'
-      end
-
-      context 'when maximum number of concurrent shells is exceeded' do
-        let(:fault) { '2150859174' }
-
-        include_examples 'retry shell command'
-      end
-    end
-
-    context 'open_shell fails' do
-      let(:retry_limit) { 2 }
-      let(:output_message2) { double('message') }
-
-      it 'retries and raises failure if it never succeeds' do
-        expect(subject).to receive(:open_shell)
-          .and_raise(Errno::ECONNREFUSED).exactly(retry_limit).times
-        expect { subject.run(command) }.to raise_error(Errno::ECONNREFUSED)
-      end
-
-      it 'retries and returns shell on success' do
-        @times = 0
-        allow(subject).to receive(:command_output_message).with('shell_id 2', command_id)
-          .and_return(output_message2)
-        allow(reader).to receive(:read_output)
-          .with(output_message2).and_return(output)
-        allow(subject).to receive(:open_shell) do
-          @times += 1
-          raise(Errno::ECONNREFUSED) if @times == 1
-          "shell_id #{@times}"
-        end
-
-        subject.run(command, arguments)
-        expect(subject.shell_id).to eq 'shell_id 2'
-      end
-    end
-  end
-
-  describe '#close' do
-    it 'does not close if not opened' do
-      expect(DummyShell).not_to receive(:close_shell)
-      subject.close
-    end
-
-    it 'close shell if opened' do
-      subject.run(command, arguments)
-      subject.close
-      expect(DummyShell.closed?).to be(true)
-    end
-
-    it 'nils out the shell_id' do
-      subject.run(command, arguments)
-      subject.close
-      expect(subject.shell_id).to be(nil)
-    end
-
-    context 'when shell was not found' do
-      it 'does not raise' do
-        subject.run(command, arguments)
-        expect(DummyShell).to receive(:close_shell)
-          .and_raise(WinRM::WinRMWSManFault.new('oops', '2150858843'))
-        expect { subject.close }.not_to raise_error
-      end
-    end
-  end
-end

data/tests/spec/shells/cmd_spec.rb

@@ -1,75 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/shells/cmd'
-
-describe WinRM::Shells::Cmd do
-  let(:retry_limit) { 1 }
-  let(:shell_id) { 'shell_id' }
-  let(:output) { 'output' }
-  let(:create_shell_payload) { 'create_shell_payload' }
-  let(:close_shell_payload) { 'close_shell_payload' }
-  let(:cleanup_payload) { 'cleanup_payload' }
-  let(:command) { 'run this command' }
-  let(:arguments) { ['args'] }
-  let(:command_response) { "<a xmlns:rsp='foo'><rsp:CommandId>command_id</rsp:CommandId></a>" }
-  let(:connection_options) { { max_commands: 100, retry_limit: retry_limit, retry_delay: 0 } }
-  let(:transport) { double('transport', send_request: nil) }
-
-  before do
-    allow_any_instance_of(WinRM::WSMV::CloseShell).to receive(:build)
-      .and_return(close_shell_payload)
-    allow_any_instance_of(WinRM::WSMV::CreateShell).to receive(:build)
-      .and_return(create_shell_payload)
-    allow_any_instance_of(WinRM::WSMV::CleanupCommand).to receive(:build)
-      .and_return(cleanup_payload)
-    allow_any_instance_of(WinRM::WSMV::ReceiveResponseReader).to receive(:read_output)
-      .and_return(output)
-    allow(transport).to receive(:send_request).with(create_shell_payload)
-      .and_return(REXML::Document.new("<blah Name='ShellId'>#{shell_id}</blah>"))
-    allow(transport).to receive(:send_request).with(/#{command}/)
-      .and_return(REXML::Document.new(command_response))
-  end
-
-  subject { described_class.new(connection_options, transport, Logging.logger['test']) }
-
-  describe '#run' do
-    it 'opens a shell and gets shell id' do
-      subject.run(command, arguments)
-      expect(subject.shell_id).to eq shell_id
-    end
-
-    it 'sends create shell through transport' do
-      expect(transport).to receive(:send_request).with(create_shell_payload)
-      subject.run(command, arguments)
-    end
-
-    it 'returns output from generated command' do
-      expect(subject.run(command, arguments)).to eq output
-    end
-
-    it 'sends command through transport' do
-      expect(transport).to receive(:send_request).with(/#{command}/)
-      subject.run(command, arguments)
-    end
-
-    it 'sends cleanup message through transport' do
-      expect(transport).to receive(:send_request).with(cleanup_payload)
-      subject.run(command, arguments)
-    end
-  end
-
-  describe '#close' do
-    it 'sends close shell through transport' do
-      subject.run(command, arguments)
-      expect(transport).to receive(:send_request).with(close_shell_payload)
-      subject.close
-    end
-
-    it 'creates a shell closer with default shell uri' do
-      allow(WinRM::WSMV::CloseShell).to receive(:new) do |_, opts|
-        expect(opts[:shell_uri]).to be nil
-      end.and_call_original
-      subject.close
-    end
-  end
-end

data/tests/spec/shells/powershell_spec.rb

@@ -1,175 +0,0 @@
-# encoding: UTF-8
-
-require 'winrm/shells/power_shell'
-
-describe WinRM::Shells::Powershell do
-  let(:retry_limit) { 1 }
-  let(:max_envelope_size_kb) { 150 }
-  let(:shell_id) { 'bc1bfbba-8215-4a04-b2df-7a3ac0310e16' }
-  let(:output) { 'output' }
-  let(:command_id) { '4218A578-0F18-4B19-82C3-46B433319126' }
-  let(:keepalive_payload) { 'keepalive_payload' }
-  let(:configuration_payload) { 'configuration_payload' }
-  let(:command_payload) { 'command_payload' }
-  let(:create_shell_payload) { 'create_shell_payload' }
-  let(:close_shell_payload) { 'close_shell_payload' }
-  let(:cleanup_payload) { 'cleanup_payload' }
-  let(:command) { 'command' }
-  let(:output_message) { double('output_message', build: 'output_message') }
-  let(:command_response) { "<a xmlns:rsp='foo'><rsp:CommandId>#{command_id}</rsp:CommandId></a>" }
-  let(:configuration_response) do
-    "<a xmlns:cfg='foo'><cfg:MaxEnvelopeSizekb>#{max_envelope_size_kb}</cfg:MaxEnvelopeSizekb></a>"
-  end
-  let(:connection_options) { { max_commands: 100, retry_limit: retry_limit, retry_delay: 0 } }
-  let(:transport) { double('transport', send_request: nil) }
-  let(:test_data_xml_template) do
-    ERB.new(stubbed_response('get_powershell_keepalive_response.xml.erb'))
-  end
-  let(:protocol_version) { 2.2 }
-  let(:test_data1) do
-    <<-EOH
-      <Obj RefId="0">
-        <MS>
-          <Version N="protocolversion">#{protocol_version}</Version>
-          <Version N="PSVersion">2.0</Version>
-          <Version N="SerializationVersion">1.1.0.1</Version>
-        </MS>
-      </Obj>
-    EOH
-  end
-  let(:test_data2) { '<Obj RefId="0"><MS><I32 N="RunspaceState">2</I32></MS></Obj>' }
-  let(:message1) do
-    WinRM::PSRP::Message.new(
-      shell_id,
-      WinRM::PSRP::Message::MESSAGE_TYPES[:session_capability],
-      test_data1,
-      command_id
-    )
-  end
-  let(:message2) do
-    WinRM::PSRP::Message.new(
-      shell_id,
-      WinRM::PSRP::Message::MESSAGE_TYPES[:runspacepool_state],
-      test_data2,
-      command_id
-    )
-  end
-  let(:fragment1) { WinRM::PSRP::Fragment.new(1, message1.bytes) }
-  let(:fragment2) { WinRM::PSRP::Fragment.new(1, message2.bytes) }
-  let(:test_data_stdout1) { Base64.strict_encode64(fragment1.bytes.pack('C*')) }
-  let(:test_data_stdout2) { Base64.strict_encode64(fragment2.bytes.pack('C*')) }
-
-  before do
-    allow(SecureRandom).to receive(:uuid).and_return(command_id)
-    allow(subject).to receive(:command_output_message).with(shell_id, command_id)
-      .and_return(output_message)
-    allow_any_instance_of(WinRM::WSMV::CreatePipeline).to receive(:build)
-      .and_return(command_payload)
-    allow_any_instance_of(WinRM::WSMV::CloseShell).to receive(:build)
-      .and_return(close_shell_payload)
-    allow_any_instance_of(WinRM::WSMV::InitRunspacePool).to receive(:build)
-      .and_return(create_shell_payload)
-    allow_any_instance_of(WinRM::WSMV::Configuration).to receive(:build)
-      .and_return(configuration_payload)
-    allow_any_instance_of(WinRM::WSMV::CleanupCommand).to receive(:build)
-      .and_return(cleanup_payload)
-    allow_any_instance_of(WinRM::WSMV::KeepAlive).to receive(:build).and_return(keepalive_payload)
-    allow_any_instance_of(WinRM::PSRP::ReceiveResponseReader).to receive(:read_output)
-      .with(output_message).and_return(output)
-    allow(transport).to receive(:send_request).with(configuration_payload).and_return(
-      REXML::Document.new(configuration_response))
-    allow(transport).to receive(:send_request).with(create_shell_payload)
-      .and_return(REXML::Document.new("<blah Name='ShellId'>#{shell_id}</blah>"))
-    allow(transport).to receive(:send_request).with(command_payload)
-      .and_return(REXML::Document.new(command_response))
-    allow(transport).to receive(:send_request).with(keepalive_payload)
-      .and_return(REXML::Document.new(test_data_xml_template.result(binding)))
-  end
-
-  subject { described_class.new(connection_options, transport, Logging.logger['test']) }
-
-  describe '#run' do
-    it 'opens a shell and gets shell id' do
-      subject.run(command)
-      expect(subject.shell_id).to eq shell_id
-    end
-
-    it 'sends create shell through transport' do
-      expect(transport).to receive(:send_request).with(create_shell_payload)
-      subject.run(command)
-    end
-
-    it 'sends keepalive shell through transport' do
-      expect(transport).to receive(:send_request).with(keepalive_payload)
-      subject.run(command)
-    end
-
-    it 'returns output from generated command' do
-      expect(subject.run(command)).to eq output
-    end
-
-    it 'sends command through transport' do
-      expect(transport).to receive(:send_request).with(command_payload)
-      subject.run(command)
-    end
-
-    it 'sends cleanup message through transport' do
-      expect(transport).to receive(:send_request).with(cleanup_payload)
-      subject.run(command)
-    end
-
-    context 'non admin user' do
-      before do
-        allow(transport).to receive(:send_request).with(configuration_payload)
-          .and_raise(WinRM::WinRMWSManFault.new('no access for you', '5'))
-      end
-
-      context 'protocol version 2.1' do
-        let(:protocol_version) { 2.1 }
-
-        it 'sets the fragmenter max_blob_length' do
-          expect_any_instance_of(WinRM::PSRP::MessageFragmenter).to receive(:max_blob_length=)
-            .with(153600)
-          subject.run(command)
-        end
-      end
-
-      context 'protocol version 2.2' do
-        let(:protocol_version) { 2.2 }
-
-        it 'sets the fragmenter max_blob_length' do
-          expect_any_instance_of(WinRM::PSRP::MessageFragmenter).to receive(:max_blob_length=)
-            .with(512000)
-          subject.run(command)
-        end
-      end
-    end
-
-    context 'fragment large command' do
-      let(:command) { 'c' * 200000 }
-
-      it 'fragments messages as large as max envelope size' do
-        allow_any_instance_of(WinRM::WSMV::CreatePipeline).to receive(:build).and_call_original
-        allow(transport).to receive(:send_request).with(/CommandLine/) do |payload|
-          expect(payload.length).to be max_envelope_size_kb * 1024
-        end.and_return(REXML::Document.new(command_response))
-        subject.run(command)
-      end
-    end
-  end
-
-  describe '#close' do
-    it 'sends close shell through transport' do
-      subject.run(command)
-      expect(transport).to receive(:send_request).with(close_shell_payload)
-      subject.close
-    end
-
-    it 'creates a shell closer with powershell uri' do
-      allow(WinRM::WSMV::CloseShell).to receive(:new) do |_, opts|
-        expect(opts[:shell_uri]).to be WinRM::WSMV::Header::RESOURCE_URI_POWERSHELL
-      end.and_call_original
-      subject.close
-    end
-  end
-end

data/tests/spec/spec_helper.rb

@@ -1,47 +0,0 @@
-# encoding: UTF-8
-require 'rubygems'
-require 'bundler/setup'
-require 'winrm'
-require 'json'
-require_relative '../matchers'
-
-# Unit test spec helper
-module SpecUnitHelper
-  def stubbed_response(file)
-    File.read("tests/spec/stubs/responses/#{file}")
-  end
-
-  def stubbed_clixml(file)
-    File.read("tests/spec/stubs/clixml/#{file}")
-  end
-
-  def default_connection_opts
-    {
-      user: 'Administrator',
-      password: 'password',
-      endpoint: 'http://localhost:5985/wsman',
-      max_envelope_size: 153600,
-      session_id: '05A2622B-B842-4EB8-8A78-0225C8A993DF',
-      operation_timeout: 60,
-      locale: 'en-US'
-    }
-  end
-end
-
-# Strip leading whitespace from each line that is the same as the
-# amount of whitespace on the first line of the string.
-# Leaves _additional_ indentation on later lines intact.
-# and remove newlines.
-class String
-  def unindent
-    gsub(/^#{self[/\A[ \t]*/]}/, '').delete("\n")
-  end
-
-  def to_byte_string
-    force_encoding(Encoding::ASCII_8BIT)
-  end
-end
-
-RSpec.configure do |config|
-  config.include(SpecUnitHelper)
-end

data/tests/spec/stubs/clixml/error_record.xml.erb

@@ -1,84 +0,0 @@
-<?xml version="1.0"?>
-<Obj RefId="0">
-    <TN RefId="0">
-        <T>System.Management.Automation.ErrorRecord</T>
-        <T>System.Object</T>
-    </TN>
-    <ToString><%= error_message %></ToString>
-    <MS>
-        <B N="writeErrorStream">true</B>
-        <Obj N="Exception" RefId="1">
-            <TN RefId="1">
-                <T>Microsoft.PowerShell.Commands.WriteErrorException</T>
-                <T>Microsoft.PowerShell.CoreClr.Stubs.SystemException</T>
-                <T>System.Exception</T>
-                <T>System.Object</T>
-            </TN>
-            <ToString>Microsoft.PowerShell.Commands.WriteErrorException: <%= error_message %></ToString>
-            <Props>
-                <S N="Message"><%= error_message %></S>
-                <Obj N="Data" RefId="2">
-                    <TN RefId="2">
-                        <T>System.Collections.ListDictionaryInternal</T>
-                        <T>System.Object</T>
-                    </TN>
-                    <DCT/>
-                </Obj>
-                <Nil N="InnerException"/>
-                <Nil N="StackTrace"/>
-                <Nil N="HelpLink"/>
-                <Nil N="Source"/>
-                <I32 N="HResult">-2146233088</I32>
-            </Props>
-        </Obj>
-        <Nil N="TargetObject"/>
-        <S N="FullyQualifiedErrorId"><%= error_id %></S>
-        <Obj N="InvocationInfo" RefId="3">
-            <TN RefId="3">
-                <T>System.Management.Automation.InvocationInfo</T>
-                <T>System.Object</T>
-            </TN>
-            <ToString>System.Management.Automation.InvocationInfo</ToString>
-            <Props>
-                <Nil N="MyCommand"/>
-                <Obj N="BoundParameters" RefId="4">
-                    <TN RefId="4">
-                        <T>System.Collections.Generic.Dictionary`2[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.Object, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]]</T>
-                        <T>System.Object</T>
-                    </TN>
-                    <DCT/>
-                </Obj>
-                <Obj N="UnboundArguments" RefId="5">
-                    <TN RefId="5">
-                        <T>System.Collections.Generic.List`1[[System.Object, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]]</T>
-                        <T>System.Object</T>
-                    </TN>
-                    <LST/>
-                </Obj>
-                <I32 N="ScriptLineNumber">1</I32>
-                <I32 N="OffsetInLine">1</I32>
-                <I64 N="HistoryId">1</I64>
-                <S N="ScriptName"/>
-                <S N="Line">write-error '<%= error_message %>'</S>
-                <S N="PositionMessage">At line:1 char:1_x000D__x000A_+ write-error '<%= error_message %>'_x000D__x000A_+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~</S>
-                <S N="PSScriptRoot"><%= script_root %></S>
-                <Nil N="PSCommandPath"/>
-                <S N="InvocationName"/>
-                <I32 N="PipelineLength">0</I32>
-                <I32 N="PipelinePosition">0</I32>
-                <B N="ExpectingInput">false</B>
-                <S N="CommandOrigin">Internal</S>
-                <Nil N="DisplayScriptPosition"/>
-            </Props>
-        </Obj>
-        <I32 N="ErrorCategory_Category">0</I32>
-        <S N="ErrorCategory_Activity">Write-Error</S>
-        <S N="ErrorCategory_Reason">WriteErrorException</S>
-        <S N="ErrorCategory_TargetName"/>
-        <S N="ErrorCategory_TargetType"/>
-        <S N="ErrorCategory_Message"><%= category_message %></S>
-        <B N="SerializeExtendedInfo">false</B>
-        <S N="ErrorDetails_ScriptStackTrace"><%= stack_trace %></S>
-        <Nil N="PSMessageDetails"/>
-    </MS>
-</Obj>