chef 16.7.61 → 16.8.9

data/lib/chef/util/powershell/cmdlet_result.rb

@@ -1,61 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-#
-# Copyright:: Copyright (c) Chef Software Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require_relative "../../json_compat"
-
-class Chef
-  class Util
-    class Powershell
-      class CmdletResult
-        attr_reader :output_format
-
-        def initialize(status, streams, output_format)
-          @status = status
-          @output_format = output_format
-          @streams = streams
-        end
-
-        def stdout
-          @status.stdout
-        end
-
-        def stderr
-          @status.stderr
-        end
-
-        def stream(name)
-          @streams[name].read
-        end
-
-        def return_value
-          if output_format == :object
-            Chef::JSONCompat.parse(stream(:json))
-          elsif output_format == :json
-            stream(:json)
-          else
-            @status.stdout
-          end
-        end
-
-        def succeeded?
-          @succeeded = @status.status.exitstatus == 0
-        end
-      end
-    end
-  end
-end

data/spec/functional/util/powershell/cmdlet_spec.rb

@@ -1,111 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@chef.io>)
-#
-# Copyright:: Copyright (c) Chef Software Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "chef/json_compat"
-require "spec_helper"
-
-describe Chef::Util::Powershell::Cmdlet, :windows_powershell_dsc_only do
-  before(:all) do
-    @node = Chef::Node.new
-    @node.consume_external_attrs(OHAI_SYSTEM.data, {})
-  end
-  let(:cmd_output_format) { :text }
-  let(:simple_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "get-childitem", cmd_output_format, { depth: 2 }) }
-  let(:invalid_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "get-idontexist", cmd_output_format) }
-  let(:cmdlet_get_item_requires_switch_or_argument) { Chef::Util::Powershell::Cmdlet.new(@node, "get-item", cmd_output_format, { depth: 2 }) }
-  let(:cmdlet_alias_requires_switch_or_argument) { Chef::Util::Powershell::Cmdlet.new(@node, "alias", cmd_output_format, { depth: 2 }) }
-  let(:etc_directory) { "#{ENV["systemroot"]}\\system32\\drivers\\etc" }
-  let(:architecture_cmdlet) { Chef::Util::Powershell::Cmdlet.new(@node, "$env:PROCESSOR_ARCHITECTURE") }
-
-  it "executes a simple process" do
-    result = simple_cmdlet.run
-    expect(result.succeeded?).to eq(true)
-  end
-
-  it "#run does not raise a PowershellCmdletException exception if the command cannot be executed" do
-    expect { invalid_cmdlet.run }.not_to raise_error
-  end
-
-  it "#run! raises a PowershellCmdletException exception if the command cannot be executed" do
-    expect { invalid_cmdlet.run! }.to raise_error(Chef::Exceptions::PowershellCmdletException)
-  end
-
-  it "executes a 64-bit command on a 64-bit OS, 32-bit otherwise" do
-    os_arch = ENV["PROCESSOR_ARCHITEW6432"]
-    if os_arch.nil?
-      os_arch = ENV["PROCESSOR_ARCHITECTURE"]
-    end
-
-    result = architecture_cmdlet.run
-    execution_arch = result.return_value
-    execution_arch.strip!
-    expect(execution_arch).to eq(os_arch)
-  end
-
-  it "passes command line switches to the command" do
-    result = cmdlet_alias_requires_switch_or_argument.run({ name: "ls" })
-    expect(result.succeeded?).to eq(true)
-  end
-
-  it "passes command line arguments to the command" do
-    result = cmdlet_alias_requires_switch_or_argument.run({}, {}, "ls")
-    expect(result.succeeded?).to eq(true)
-  end
-
-  it "passes command line arguments and switches to the command" do
-    result = cmdlet_get_item_requires_switch_or_argument.run({ path: etc_directory }, {}, " | select-object -property fullname | format-table -hidetableheaders")
-    expect(result.succeeded?).to eq(true)
-    returned_directory = result.return_value
-    returned_directory.strip!
-    expect(returned_directory).to eq(etc_directory)
-  end
-
-  it "passes execution options to the command" do
-    result = cmdlet_get_item_requires_switch_or_argument.run({}, { cwd: etc_directory }, ". | select-object -property fullname | format-table -hidetableheaders")
-    expect(result.succeeded?).to eq(true)
-    returned_directory = result.return_value
-    returned_directory.strip!
-    expect(returned_directory).to eq(etc_directory)
-  end
-
-  context "when returning json" do
-    let(:cmd_output_format) { :json }
-    it "returns json format data" do
-      result = cmdlet_alias_requires_switch_or_argument.run({}, {}, "ls")
-      expect(result.succeeded?).to eq(true)
-      expect { Chef::JSONCompat.parse(result.return_value) }.not_to raise_error
-    end
-  end
-
-  context "when returning Ruby objects" do
-    let(:cmd_output_format) { :object }
-    it "returns object format data" do
-      result = simple_cmdlet.run({}, { cwd: etc_directory }, "hosts")
-      expect(result.succeeded?).to eq(true)
-      data = result.return_value
-      expect(data["Name"]).to eq("hosts")
-    end
-  end
-
-  context "when constructor is given invalid arguments" do
-    let(:cmd_output_format) { :invalid }
-    it "throws an exception if an invalid format is passed to the constructor" do
-      expect { simple_cmdlet }.to raise_error(ArgumentError)
-    end
-  end
-end

data/spec/unit/util/powershell/cmdlet_spec.rb

@@ -1,106 +0,0 @@
-#
-# Author:: Jay Mundrawala <jdm@chef.io>
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "chef"
-require "chef/util/powershell/cmdlet"
-
-describe Chef::Util::Powershell::Cmdlet do
-  before (:all) do
-    @node = Chef::Node.new
-    @cmdlet = Chef::Util::Powershell::Cmdlet.new(@node, "Some-Commandlet")
-  end
-
-  describe "#validate_switch_name!" do
-    it "should not raise an error if a name contains all upper case letters" do
-      @cmdlet.send(:validate_switch_name!, "HELLO")
-    end
-
-    it "should not raise an error if the name contains all lower case letters" do
-      @cmdlet.send(:validate_switch_name!, "hello")
-    end
-
-    it "should not raise an error if no special characters are used except _" do
-      @cmdlet.send(:validate_switch_name!, "hello_world")
-    end
-
-    %w{! @ # $ % ^ & * & * ( ) - = + \{ \} . ? < > \\ /}.each do |sym|
-      it "raises an Argument error if it configuration name contains #{sym}" do
-        expect do
-          @cmdlet.send(:validate_switch_name!, "Hello#{sym}")
-        end.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#escape_parameter_value" do
-    # Is this list really complete?
-    %w{` " # '}.each do |c|
-      it "escapse #{c}" do
-        expect(@cmdlet.send(:escape_parameter_value, "stuff #{c}")).to eql("stuff `#{c}")
-      end
-    end
-
-    it "does not do anything to a string without special characters" do
-      expect(@cmdlet.send(:escape_parameter_value, "stuff")).to eql("stuff")
-    end
-  end
-
-  describe "#escape_string_parameter_value" do
-    it "surrounds a string with ''" do
-      expect(@cmdlet.send(:escape_string_parameter_value, "stuff")).to eql("'stuff'")
-    end
-  end
-
-  describe "#command_switches_string" do
-    it "raises an ArgumentError if the key is not a symbol" do
-      expect do
-        @cmdlet.send(:command_switches_string, { "foo" => "bar" })
-      end.to raise_error(ArgumentError)
-    end
-
-    it "does not allow invalid switch names" do
-      expect do
-        @cmdlet.send(:command_switches_string, { foo!: "bar" })
-      end.to raise_error(ArgumentError)
-    end
-
-    it "ignores switches with a false value" do
-      expect(@cmdlet.send(:command_switches_string, { foo: false })).to eql("")
-    end
-
-    it "should correctly handle a value type of string" do
-      expect(@cmdlet.send(:command_switches_string, { foo: "bar" })).to eql("-foo 'bar'")
-    end
-
-    it "should correctly handle a value type of string even when it is 0 length" do
-      expect(@cmdlet.send(:command_switches_string, { foo: "" })).to eql("-foo ''")
-    end
-
-    it "should not quote integers" do
-      expect(@cmdlet.send(:command_switches_string, { foo: 1 })).to eql("-foo 1")
-    end
-
-    it "should not quote floats" do
-      expect(@cmdlet.send(:command_switches_string, { foo: 1.0 })).to eql("-foo 1.0")
-    end
-
-    it "has just the switch when the value is true" do
-      expect(@cmdlet.send(:command_switches_string, { foo: true })).to eql("-foo")
-    end
-  end
-end