knife-windows 3.0.6 → 3.0.10

data/lib/chef/knife/winrm_session.rb

@@ -16,9 +16,9 @@
 # limitations under the License.
 #
 
-require 'chef/application'
-require 'winrm'
-require 'winrm-elevated'
+require "chef/application"
+require "winrm"
+require "winrm-elevated"
 
 class Chef
   class Knife
@@ -34,10 +34,10 @@ class Chef
         @shell_args = [ options[:shell] ]
         @shell_args << { codepage: options[:codepage] } if options[:shell] == :cmd
         url = "#{options[:host]}:#{options[:port]}/wsman"
-        scheme = options[:transport] == :ssl ? 'https' : 'http'
+        scheme = options[:transport] == :ssl ? "https" : "http"
         @endpoint = "#{scheme}://#{url}"
 
-        opts = Hash.new
+        opts = {}
         opts = {
           user: @user,
           password: options[:password],
@@ -46,9 +46,9 @@ class Chef
           no_ssl_peer_verification: options[:no_ssl_peer_verification],
           ssl_peer_fingerprint: options[:ssl_peer_fingerprint],
           endpoint: endpoint,
-          transport: options[:transport]
+          transport: options[:transport],
         }
-        options[:transport] == :kerberos ? opts.merge!({:service => options[:service], :realm => options[:realm]}) : opts.merge!({:ca_trust_path => options[:ca_trust_path]})
+        options[:transport] == :kerberos ? opts.merge!({ service: options[:service], realm: options[:realm] }) : opts.merge!({ ca_trust_path: options[:ca_trust_path] })
         opts[:operation_timeout] = options[:operation_timeout] if options[:operation_timeout]
         Chef::Log.debug("WinRM::WinRMWebService options: #{opts}")
         Chef::Log.debug("Endpoint: #{endpoint}")

data/lib/chef/knife/winrm_shared_options.rb

@@ -16,9 +16,9 @@
 # limitations under the License.
 #
 
-require 'chef/knife'
-require 'chef/encrypted_data_bag_item'
-require 'kconv'
+require "chef/knife"
+require "chef/encrypted_data_bag_item"
+require "kconv"
 
 class Chef
   class Knife
@@ -28,24 +28,24 @@ class Chef
       def self.included(includer)
         includer.class_eval do
           option :manual,
-            :short => "-m",
-            :long => "--manual-list",
-            :boolean => true,
-            :description => "QUERY is a space separated list of servers",
-            :default => false
+            short: "-m",
+            long: "--manual-list",
+            boolean: true,
+            description: "QUERY is a space separated list of servers",
+            default: false
 
           option :attribute,
-            :short => "-a ATTR",
-            :long => "--attribute ATTR",
-            :description => "The attribute to use for opening the connection - default is fqdn",
-            :default => "fqdn"
+            short: "-a ATTR",
+            long: "--attribute ATTR",
+            description: "The attribute to use for opening the connection - default is fqdn",
+            default: "fqdn"
 
           option :concurrency,
-            :short => "-C NUM",
-            :long => "--concurrency NUM",
-            :description => "The number of allowed concurrent connections",
-            :default => 1,
-            :proc => lambda { |o| o.to_i }
+            short: "-C NUM",
+            long: "--concurrency NUM",
+            description: "The number of allowed concurrent connections",
+            default: 1,
+            proc: lambda { |o| o.to_i }
         end
       end
 

data/lib/chef/knife/wsman_endpoint.rb

@@ -36,7 +36,7 @@ class Chef
 
       def to_hash
         hash = {}
-        instance_variables.each {|var| hash[var.to_s.delete("@")] = instance_variable_get(var) }
+        instance_variables.each { |var| hash[var.to_s.delete("@")] = instance_variable_get(var) }
         hash
       end
     end

data/lib/chef/knife/wsman_test.rb

@@ -16,10 +16,10 @@
 # limitations under the License.
 #
 
-require 'httpclient'
-require 'chef/knife'
-require_relative 'winrm_knife_base'
-require_relative 'wsman_endpoint'
+require "httpclient"
+require "chef/knife"
+require_relative "winrm_knife_base"
+require_relative "wsman_endpoint"
 
 class Chef
   class Knife
@@ -28,7 +28,7 @@ class Chef
       include Chef::Knife::WinrmCommandSharedFunctions
 
       deps do
-        require 'chef/search/query'
+        require "chef/search/query"
       end
 
       banner "knife wsman test QUERY (options)"
@@ -36,7 +36,7 @@ class Chef
       def run
         # pass a dummy password to avoid prompt for password
         # but it does nothing
-        @config[:winrm_password] = 'cute_little_kittens'
+        @config[:winrm_password] = "cute_little_kittens"
 
         configure_session
         verify_wsman_accessiblity_for_nodes
@@ -81,8 +81,8 @@ class Chef
       def post_identity_request(endpoint)
         xml = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope" xmlns:wsmid="http://schemas.dmtf.org/wbem/wsman/identity/1/wsmanidentity.xsd"><s:Header/><s:Body><wsmid:Identify/></s:Body></s:Envelope>'
         header = {
-          'WSMANIDENTIFY' => 'unauthenticated',
-          'Content-Type' => 'application/soap+xml; charset=UTF-8'
+          "WSMANIDENTIFY" => "unauthenticated",
+          "Content-Type" => "application/soap+xml; charset=UTF-8",
         }
 
         client = HTTPClient.new
@@ -101,7 +101,7 @@ class Chef
           doc = REXML::Document.new(response.body)
           output_object.protocol_version = search_xpath(doc, "//wsmid:ProtocolVersion")
           output_object.product_version  = search_xpath(doc, "//wsmid:ProductVersion")
-          output_object.product_vendor  = search_xpath(doc, "//wsmid:ProductVendor")
+          output_object.product_vendor = search_xpath(doc, "//wsmid:ProductVendor")
           if output_object.protocol_version.to_s.strip.length == 0
             output_object.error_message = "Endpoint #{node.endpoint} on #{node.host} does not appear to be a WSMAN endpoint. Response body was #{response.body}"
           end
@@ -111,7 +111,7 @@ class Chef
 
       def search_xpath(document, property_name)
         result = REXML::XPath.match(document, property_name)
-        result[0].nil? ? '' : result[0].text
+        result[0].nil? ? "" : result[0].text
       end
     end
   end

data/lib/knife-windows/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Windows
-    VERSION = "3.0.6"
-    MAJOR, MINOR, TINY = VERSION.split('.')
+    VERSION = "3.0.10".freeze
+    MAJOR, MINOR, TINY = VERSION.split(".")
   end
 end

data/spec/dummy_winrm_connection.rb

@@ -2,7 +2,6 @@ module Dummy
   class WinRMTransport
     attr_reader :httpcli
 
-
     def initialize
       @httpcli = HTTPClient.new
     end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 
 # Author:: Adam Edwards (<adamed@chef.io>)
-# Copyright:: Copyright (c) 2012-2017 Chef Software, Inc.
+# Copyright:: Copyright (c) 2012-2020 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,90 +17,15 @@
 # limitations under the License.
 #
 
-def windows?
-  !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
-end
-
-require_relative '../lib/chef/knife/winrm'
-require_relative '../lib/chef/knife/wsman_test'
-
-if windows?
-  require 'ruby-wmi'
-end
-
-def windows2012?
-  is_win2k12 = false
-
-  if  windows?
-    this_operating_system = WMI::Win32_OperatingSystem.find(:first)
-    os_version = this_operating_system.send('Version')
-
-    # The operating system version is a string in the following form
-    # that can be split into components based on the '.' delimiter:
-    # MajorVersionNumber.MinorVersionNumber.BuildNumber
-    os_version_components = os_version.split('.')
-
-    if os_version_components.length < 2
-      raise 'WMI returned a Windows version from Win32_OperatingSystem.Version ' +
-        'with an unexpected format. The Windows version could not be determined.'
-    end
-
-    # Windows 6.2 is Windows Server 2012, so test the major and
-    # minor version components
-    is_win2k12 = os_version_components[0] == '6' && os_version_components[1] == '2'
-  end
-
-  is_win2k12
-end
-
-def windows2016?
-  is_win2k16 = false
-
-  if  windows?
-    this_operating_system = WMI::Win32_OperatingSystem.find(:first)
-    os_version = this_operating_system.send('Version')
-
-    # The operating system version is a string in the following form
-    # that can be split into components based on the '.' delimiter:
-    # MajorVersionNumber.MinorVersionNumber.BuildNumber
-    os_version_components = os_version.split('.')
-
-    if os_version_components.length < 2
-      raise 'WMI returned a Windows version from Win32_OperatingSystem.Version ' +
-        'with an unexpected format. The Windows version could not be determined.'
-    end
-
-    # Windows 10.0 is Windows Server 2016, so test the major and
-    # minor version components
-    is_win2k16 = os_version_components[0] == '10' && os_version_components[1] == '0'
-  end
-
-  is_win2k16
-end
-
-def chef_gte_13?
-  Gem::Version.new(Chef::VERSION) >= Gem::Version.new('13')
-end
-
-def chef_lt_14?
-  Gem::Version.new(Chef::VERSION) < Gem::Version.new('14')
-end
-
-def chef_gte_14?
-  Gem::Version.new(Chef::VERSION) >= Gem::Version.new('14')
-end
+require_relative "../lib/chef/knife/winrm"
+require_relative "../lib/chef/knife/wsman_test"
 
 def sample_data(file_name)
-  file =  File.expand_path(File.dirname("spec/assets/*"))+"/#{file_name}"
+  file = File.expand_path(File.dirname("spec/assets/*")) + "/#{file_name}"
   File.read(file)
 end
 
 RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
-  config.filter_run :focus => true
-  config.filter_run_excluding :windows_only => true unless windows?
-  config.filter_run_excluding :windows_2012_only => true unless windows2012?
-  config.filter_run_excluding :chef_gte_13_only => true unless chef_gte_13?
-  config.filter_run_excluding :chef_lt_14_only => true unless chef_lt_14?
-  config.filter_run_excluding :chef_gte_14_only => true unless chef_gte_14?
+  config.filter_run focus: true
 end

data/spec/unit/knife/windows_cert_generate_spec.rb

@@ -16,13 +16,13 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/knife/windows_cert_generate'
-require 'openssl'
+require "spec_helper"
+require "chef/knife/windows_cert_generate"
+require "openssl"
 
 describe Chef::Knife::WindowsCertGenerate do
   before(:all) do
-    @certgen = Chef::Knife::WindowsCertGenerate.new(["-H","something.mydomain.com"])
+    @certgen = Chef::Knife::WindowsCertGenerate.new(["-H", "something.mydomain.com"])
   end
 
   it "generates RSA key pair" do
@@ -62,7 +62,7 @@ describe Chef::Knife::WindowsCertGenerate do
     end
 
     it "writes out certificates" do
-      @certgen.config[:output_file] = 'winrmcert'
+      @certgen.config[:output_file] = "winrmcert"
 
       expect(@certgen).to receive(:certificates_already_exist?).and_return(false)
       expect(@certgen).to receive(:write_certificate_to_file)
@@ -70,7 +70,7 @@ describe Chef::Knife::WindowsCertGenerate do
     end
 
     it "prompts when certificates already exist" do
-      file_path = 'winrmcert'
+      file_path = "winrmcert"
       @certgen.config[:output_file] = file_path
 
       allow(Dir).to receive(:glob).and_return([file_path])

data/spec/unit/knife/windows_cert_install_spec.rb

@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/knife/windows_cert_install'
+require "spec_helper"
+require "chef/knife/windows_cert_install"
 
 describe Chef::Knife::WindowsCertInstall do
   context "on Windows" do

data/spec/unit/knife/windows_listener_create_spec.rb

@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/knife/windows_listener_create'
+require "spec_helper"
+require "chef/knife/windows_listener_create"
 
 describe Chef::Knife::WindowsListenerCreate do
   context "on Windows" do

data/spec/unit/knife/winrm_session_spec.rb

@@ -16,12 +16,11 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'dummy_winrm_connection'
+require "spec_helper"
+require "dummy_winrm_connection"
 
 Chef::Knife::Winrm.load_deps
 
-
 describe Chef::Knife::WinrmSession do
   let(:winrm_connection) { Dummy::Connection.new }
   let(:options) { { transport: :plaintext } }
@@ -39,8 +38,8 @@ describe Chef::Knife::WinrmSession do
 
   describe "#initialize" do
     context "when a proxy is configured" do
-      let(:proxy_uri) { 'blah.com' }
-      let(:ssl_policy) { double('DefaultSSLPolicy', :set_custom_certs => nil) }
+      let(:proxy_uri) { "blah.com" }
+      let(:ssl_policy) { double("DefaultSSLPolicy", set_custom_certs: nil) }
 
       before do
         Chef::Config[:http_proxy] = proxy_uri
@@ -48,7 +47,7 @@ describe Chef::Knife::WinrmSession do
 
       it "sets the http_proxy to the configured proxy" do
         subject
-        expect(ENV['HTTP_PROXY']).to eq("http://#{proxy_uri}")
+        expect(ENV["HTTP_PROXY"]).to eq("http://#{proxy_uri}")
       end
 
       it "sets the ssl policy on the winrm client" do
@@ -69,7 +68,7 @@ describe Chef::Knife::WinrmSession do
     end
 
     it "exits with 401 if command execution raises a 401" do
-      expect(winrm_connection).to receive(:shell).and_raise(WinRM::WinRMHTTPTransportError.new('', '401'))
+      expect(winrm_connection).to receive(:shell).and_raise(WinRM::WinRMHTTPTransportError.new("", "401"))
       expect { subject.relay_command("cmd.exe echo 'hi'") }.to raise_error(WinRM::WinRMHTTPTransportError)
       expect(subject.exit_code).to eql(401)
     end

data/spec/unit/knife/winrm_spec.rb

@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'dummy_winrm_connection'
+require "spec_helper"
+require "dummy_winrm_connection"
 
 Chef::Knife::Winrm.load_deps
 
@@ -43,7 +43,7 @@ describe Chef::Knife::Winrm do
     context "when there are some hosts found but they do not have an attribute to connect with" do
       before do
         @knife.config[:manual] = false
-        @knife.config[:winrm_password] = 'P@ssw0rd!'
+        @knife.config[:winrm_password] = "P@ssw0rd!"
         allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]])
         @node_foo.automatic_attrs[:fqdn] = nil
         @node_bar.automatic_attrs[:fqdn] = nil
@@ -61,7 +61,7 @@ describe Chef::Knife::Winrm do
     context "when there are nested attributes" do
       before do
         @knife.config[:manual] = false
-        @knife.config[:winrm_password] = 'P@ssw0rd!'
+        @knife.config[:winrm_password] = "P@ssw0rd!"
         allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]])
         allow(Chef::Search::Query).to receive(:new).and_return(@query)
       end
@@ -75,28 +75,28 @@ describe Chef::Knife::Winrm do
   end
 
   describe "#configure_session" do
-    let(:winrm_user) { 'testuser' }
-    let(:transport) { 'plaintext' }
-    let(:password) { 'testpassword' }
-    let(:protocol) { 'basic' }
+    let(:winrm_user) { "testuser" }
+    let(:transport) { "plaintext" }
+    let(:password) { "testpassword" }
+    let(:protocol) { "basic" }
     let(:knife_args) do
       [
-        '-m', 'localhost',
-        '-x', winrm_user,
-        '-P', password,
-        '-w', transport,
-        '--winrm-authentication-protocol', protocol,
-        'echo helloworld'
+        "-m", "localhost",
+        "-x", winrm_user,
+        "-P", password,
+        "-w", transport,
+        "--winrm-authentication-protocol", protocol,
+        "echo helloworld"
       ]
     end
-    let(:winrm_session) { double('winrm_session') }
+    let(:winrm_session) { double("winrm_session") }
     let(:winrm_connection) { Dummy::Connection.new }
 
     subject { Chef::Knife::Winrm.new(knife_args) }
 
     context "when configuring the WinRM user name" do
       context "when basic auth is used" do
-        let(:protocol) { 'basic' }
+        let(:protocol) { "basic" }
 
         it "passes user name as given in options" do
           expect(Chef::Knife::WinrmSession).to receive(:new) do |opts|
@@ -107,7 +107,7 @@ describe Chef::Knife::Winrm do
       end
 
       context "when negotiate auth is used" do
-        let(:protocol) { 'negotiate' }
+        let(:protocol) { "negotiate" }
 
         context "when user is prefixed with realm" do
           let(:winrm_user) { "my_realm\\myself" }
@@ -153,14 +153,14 @@ describe Chef::Knife::Winrm do
       context "when no password is given in the options" do
         let(:knife_args) do
           [
-            '-m', 'localhost',
-            '-x', winrm_user,
-            '-w', transport,
-            '--winrm-authentication-protocol', protocol,
-            'echo helloworld'
+            "-m", "localhost",
+            "-x", winrm_user,
+            "-w", transport,
+            "--winrm-authentication-protocol", protocol,
+            "echo helloworld"
           ]
         end
-        let(:prompted_password) { 'prompted_password' }
+        let(:prompted_password) { "prompted_password" }
 
         before do
           allow(subject.ui).to receive(:ask).and_return(prompted_password)
@@ -177,41 +177,45 @@ describe Chef::Knife::Winrm do
 
     context "when configuring the WinRM transport" do
       context "kerberos option is set" do
-        let(:winrm_command_http) { Chef::Knife::Winrm.new([
-          '-m', 'localhost',
-          '-x', 'testuser',
-          '-P', 'testpassword',
-          '--winrm-authentication-protocol', 'basic',
-          '--kerberos-realm', 'realm',
-          'echo helloworld'
-        ]) }
+        let(:winrm_command_http) {
+          Chef::Knife::Winrm.new([
+          "-m", "localhost",
+          "-x", "testuser",
+          "-P", "testpassword",
+          "--winrm-authentication-protocol", "basic",
+          "--kerberos-realm", "realm",
+          "echo helloworld"
+        ])
+        }
 
         it "sets the transport to kerberos" do
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:transport => :kerberos)).and_return(winrm_connection)
+          expect(WinRM::Connection).to receive(:new).with(hash_including(transport: :kerberos)).and_return(winrm_connection)
           winrm_command_http.configure_chef
           winrm_command_http.configure_session
         end
       end
 
       context "kerberos option is set but nil" do
-        let(:winrm_command_http) { Chef::Knife::Winrm.new([
-          '-m', 'localhost',
-          '-x', 'testuser',
-          '-P', 'testpassword',
-          '--winrm-authentication-protocol', 'basic',
-          'echo helloworld'
-        ]) }
+        let(:winrm_command_http) {
+          Chef::Knife::Winrm.new([
+          "-m", "localhost",
+          "-x", "testuser",
+          "-P", "testpassword",
+          "--winrm-authentication-protocol", "basic",
+          "echo helloworld"
+        ])
+        }
 
         it "sets the transport to plaintext" do
           winrm_command_http.config[:kerberos_realm] = nil
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:transport => :plaintext)).and_return(winrm_connection)
+          expect(WinRM::Connection).to receive(:new).with(hash_including(transport: :plaintext)).and_return(winrm_connection)
           winrm_command_http.configure_chef
           winrm_command_http.configure_session
         end
       end
 
       context "on windows workstations" do
-        let(:protocol) { 'negotiate' }
+        let(:protocol) { "negotiate" }
 
         before do
           allow(Chef::Platform).to receive(:windows?).and_return(true)
@@ -230,88 +234,88 @@ describe Chef::Knife::Winrm do
           allow(Chef::Platform).to receive(:windows?).and_return(false)
         end
 
-        let(:winrm_command_http) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '-w', 'plaintext', '--winrm-authentication-protocol', 'basic', 'echo helloworld']) }
+        let(:winrm_command_http) { Chef::Knife::Winrm.new(["-m", "localhost", "-x", "testuser", "-P", "testpassword", "-w", "plaintext", "--winrm-authentication-protocol", "basic", "echo helloworld"]) }
 
         it "defaults to the http uri scheme" do
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :plaintext)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:endpoint => 'http://localhost:5985/wsman')).and_return(winrm_connection)
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :plaintext)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(endpoint: "http://localhost:5985/wsman")).and_return(winrm_connection)
           winrm_command_http.configure_chef
           winrm_command_http.configure_session
         end
 
         it "sets the operation timeout and verifes default" do
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:operation_timeout => 1800)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:operation_timeout => 1800)).and_return(winrm_connection)
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(operation_timeout: 1800)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(operation_timeout: 1800)).and_return(winrm_connection)
           winrm_command_http.configure_chef
           winrm_command_http.configure_session
         end
 
         it "sets the user specified winrm port" do
-          Chef::Config[:knife] = {winrm_port: "5988"}
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :plaintext)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:transport => :plaintext)).and_return(winrm_connection)
+          Chef::Config[:knife] = { winrm_port: "5988" }
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :plaintext)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(transport: :plaintext)).and_return(winrm_connection)
           winrm_command_http.configure_chef
           winrm_command_http.configure_session
         end
 
-        let(:winrm_command_timeout) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-authentication-protocol', 'basic', '--session-timeout', '10', 'echo helloworld']) }
+        let(:winrm_command_timeout) { Chef::Knife::Winrm.new(["-m", "localhost", "-x", "testuser", "-P", "testpassword", "--winrm-authentication-protocol", "basic", "--session-timeout", "10", "echo helloworld"]) }
 
         it "sets operation timeout and verify 10 Minute timeout" do
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:operation_timeout => 600)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:operation_timeout => 600)).and_return(winrm_connection)
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(operation_timeout: 600)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(operation_timeout: 600)).and_return(winrm_connection)
           winrm_command_timeout.configure_chef
           winrm_command_timeout.configure_session
         end
 
-        let(:winrm_command_https) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', 'echo helloworld']) }
+        let(:winrm_command_https) { Chef::Knife::Winrm.new(["-m", "localhost", "-x", "testuser", "-P", "testpassword", "--winrm-transport", "ssl", "echo helloworld"]) }
 
         it "uses the https uri scheme if the ssl transport is specified" do
-          Chef::Config[:knife] = {:winrm_transport => 'ssl'}
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:endpoint => 'https://localhost:5986/wsman')).and_return(winrm_connection)
+          Chef::Config[:knife] = { winrm_transport: "ssl" }
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :ssl)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(endpoint: "https://localhost:5986/wsman")).and_return(winrm_connection)
           winrm_command_https.configure_chef
           winrm_command_https.configure_session
         end
 
         it "uses the winrm port '5986' by default for ssl transport" do
-          Chef::Config[:knife] = {:winrm_transport => 'ssl'}
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:endpoint => 'https://localhost:5986/wsman')).and_return(winrm_connection)
+          Chef::Config[:knife] = { winrm_transport: "ssl" }
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :ssl)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(endpoint: "https://localhost:5986/wsman")).and_return(winrm_connection)
           winrm_command_https.configure_chef
           winrm_command_https.configure_session
         end
 
         it "defaults to validating the server when the ssl transport is used" do
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:no_ssl_peer_verification => false)).and_return(winrm_connection)
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :ssl)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(no_ssl_peer_verification: false)).and_return(winrm_connection)
           winrm_command_https.configure_chef
           winrm_command_https.configure_session
         end
 
-        let(:winrm_command_verify_peer) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', '--winrm-ssl-verify-mode', 'verify_peer', 'echo helloworld'])}
+        let(:winrm_command_verify_peer) { Chef::Knife::Winrm.new(["-m", "localhost", "-x", "testuser", "-P", "testpassword", "--winrm-transport", "ssl", "--winrm-ssl-verify-mode", "verify_peer", "echo helloworld"]) }
 
         it "validates the server when the ssl transport is used and the :winrm_ssl_verify_mode option is not configured to :verify_none" do
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:no_ssl_peer_verification => false)).and_return(winrm_connection)
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :ssl)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(no_ssl_peer_verification: false)).and_return(winrm_connection)
           winrm_command_verify_peer.configure_chef
           winrm_command_verify_peer.configure_session
         end
 
         context "when setting verify_none" do
-          let(:transport) { 'ssl' }
+          let(:transport) { "ssl" }
 
-          before { knife_args << '--winrm-ssl-verify-mode' << 'verify_none' }
+          before { knife_args << "--winrm-ssl-verify-mode" << "verify_none" }
 
           it "does not validate the server when the ssl transport is used and the :winrm_ssl_verify_mode option is set to :verify_none" do
-            expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
-            expect(WinRM::Connection).to receive(:new).with(hash_including(:no_ssl_peer_verification => true)).and_return(winrm_connection)
+            expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :ssl)).and_call_original
+            expect(WinRM::Connection).to receive(:new).with(hash_including(no_ssl_peer_verification: true)).and_return(winrm_connection)
             subject.configure_chef
             subject.configure_session
           end
 
           it "prints warning output when the :winrm_ssl_verify_mode set to :verify_none to disable server validation" do
-            expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
-            expect(WinRM::Connection).to receive(:new).with(hash_including(:no_ssl_peer_verification => true)).and_return(winrm_connection)
+            expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :ssl)).and_call_original
+            expect(WinRM::Connection).to receive(:new).with(hash_including(no_ssl_peer_verification: true)).and_return(winrm_connection)
             expect(subject).to receive(:warn_no_ssl_peer_verification)
 
             subject.configure_chef
@@ -319,10 +323,10 @@ describe Chef::Knife::Winrm do
           end
 
           context "when transport is plaintext" do
-            let(:transport) { 'plaintext' }
+            let(:transport) { "plaintext" }
 
             it "does not print warning re ssl server validation" do
-              expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :plaintext)).and_call_original
+              expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :plaintext)).and_call_original
               expect(WinRM::Connection).to receive(:new).and_return(winrm_connection)
               expect(subject).to_not receive(:warn_no_ssl_peer_verification)
 
@@ -332,11 +336,11 @@ describe Chef::Knife::Winrm do
           end
         end
 
-        let(:winrm_command_ca_trust) { Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-transport', 'ssl', '--ca-trust-file', '~/catrustroot', '--winrm-ssl-verify-mode', 'verify_none', 'echo helloworld'])}
+        let(:winrm_command_ca_trust) { Chef::Knife::Winrm.new(["-m", "localhost", "-x", "testuser", "-P", "testpassword", "--winrm-transport", "ssl", "--ca-trust-file", "~/catrustroot", "--winrm-ssl-verify-mode", "verify_none", "echo helloworld"]) }
 
         it "validates the server when the ssl transport is used and the :ca_trust_file option is specified even if the :winrm_ssl_verify_mode option is set to :verify_none" do
-          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(:transport => :ssl)).and_call_original
-          expect(WinRM::Connection).to receive(:new).with(hash_including(:no_ssl_peer_verification => false)).and_return(winrm_connection)
+          expect(Chef::Knife::WinrmSession).to receive(:new).with(hash_including(transport: :ssl)).and_call_original
+          expect(WinRM::Connection).to receive(:new).with(hash_including(no_ssl_peer_verification: false)).and_return(winrm_connection)
           winrm_command_ca_trust.configure_chef
           winrm_command_ca_trust.configure_session
         end
@@ -351,15 +355,15 @@ describe Chef::Knife::Winrm do
         password: "testpassword",
         port: "5985",
         transport: :plaintext,
-        host: "localhost"
+        host: "localhost",
       }
     end
     let(:session) { Chef::Knife::WinrmSession.new(session_opts) }
 
     before(:each) do
       allow(Chef::Knife::WinrmSession).to receive(:new).and_return(session)
-      Chef::Config[:knife] = {:winrm_transport => 'plaintext'}
-      @winrm = Chef::Knife::Winrm.new(['-m', 'localhost', '-x', 'testuser', '-P', 'testpassword', '--winrm-authentication-protocol', 'basic', 'echo helloworld'])
+      Chef::Config[:knife] = { winrm_transport: "plaintext" }
+      @winrm = Chef::Knife::Winrm.new(["-m", "localhost", "-x", "testuser", "-P", "testpassword", "--winrm-authentication-protocol", "basic", "echo helloworld"])
     end
 
     it "returns with 0 if the command succeeds" do
@@ -383,7 +387,7 @@ describe Chef::Knife::Winrm do
     it "exits with non-zero status if the command fails and returns config is set to 0" do
       command_status = 1
       @winrm.config[:returns] = "0,53"
-      Chef::Config[:knife][:returns] = [0,53]
+      Chef::Config[:knife][:returns] = [0, 53]
       allow(@winrm).to receive(:relay_winrm_command).and_return(command_status)
       allow(@winrm.ui).to receive(:error)
       allow(session).to receive(:exit_code).and_return(command_status)
@@ -392,31 +396,31 @@ describe Chef::Knife::Winrm do
 
     it "exits with a zero status if the command returns an expected non-zero status" do
       command_status = 53
-      Chef::Config[:knife][:returns] = [0,53]
+      Chef::Config[:knife][:returns] = [0, 53]
       allow(@winrm).to receive(:relay_winrm_command).and_return(command_status)
-      allow(session).to receive(:exit_codes).and_return({"thishost" => command_status})
+      allow(session).to receive(:exit_codes).and_return({ "thishost" => command_status })
       exit_code = @winrm.run
       expect(exit_code).to be_zero
     end
 
     it "exits with a zero status if the command returns an expected non-zero status" do
       command_status = 53
-      @winrm.config[:returns] = '0,53'
+      @winrm.config[:returns] = "0,53"
       allow(@winrm).to receive(:relay_winrm_command).and_return(command_status)
-      allow(session).to receive(:exit_codes).and_return({"thishost" => command_status})
+      allow(session).to receive(:exit_codes).and_return({ "thishost" => command_status })
       exit_code = @winrm.run
       expect(exit_code).to be_zero
     end
 
     it "exits with 100 and no hint if command execution raises an exception other than 401" do
-      allow(@winrm).to receive(:relay_winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('', '500'))
+      allow(@winrm).to receive(:relay_winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new("", "500"))
       allow(@winrm.ui).to receive(:error)
       expect(@winrm.ui).to_not receive(:info)
       expect { @winrm.run_with_pretty_exceptions }.to raise_error(SystemExit) { |e| expect(e.status).to eq(100) }
     end
 
     it "exits with 100 if command execution raises a 401" do
-      allow(@winrm).to receive(:relay_winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new('', '401'))
+      allow(@winrm).to receive(:relay_winrm_command).and_raise(WinRM::WinRMHTTPTransportError.new("", "401"))
       allow(@winrm.ui).to receive(:info)
       allow(@winrm.ui).to receive(:error)
       expect { @winrm.run_with_pretty_exceptions }.to raise_error(SystemExit) { |e| expect(e.status).to eq(100) }
@@ -436,7 +440,7 @@ describe Chef::Knife::Winrm do
     it "prints a hint on failure for basic authentication" do
       @winrm.config[:winrm_authentication_protocol] = "basic"
       @winrm.config[:winrm_transport] = "plaintext"
-      allow(session).to receive(:relay_command).and_raise(WinRM::WinRMHTTPTransportError.new('', '401'))
+      allow(session).to receive(:relay_command).and_raise(WinRM::WinRMHTTPTransportError.new("", "401"))
       allow(@winrm.ui).to receive(:error)
       allow(@winrm.ui).to receive(:info)
       expect(@winrm.ui).to receive(:info).with(Chef::Knife::Winrm::FAILED_BASIC_HINT)
@@ -445,7 +449,7 @@ describe Chef::Knife::Winrm do
 
     context "when winrm_authentication_protocol specified" do
       before do
-        Chef::Config[:knife] = {:winrm_transport => 'plaintext'}
+        Chef::Config[:knife] = { winrm_transport: "plaintext" }
         allow(@winrm).to receive(:relay_winrm_command).and_return(0)
       end