chef 18.8.11 → 18.8.54

data/spec/unit/util/dsc/local_configuration_manager_spec.rb

@@ -1,192 +0,0 @@
-#
-# Author:: Adam Edwards <adamed@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/dsc/local_configuration_manager"
-
-describe Chef::Util::DSC::LocalConfigurationManager do
-
-  let(:lcm) { Chef::Util::DSC::LocalConfigurationManager.new(nil, "tmp") }
-
-  let(:normal_lcm_output) do
-    <<~EOH
-      logtype: [machinename]: LCM:  [ Start  Set      ]
-      logtype: [machinename]: LCM:  [ Start  Resource ] [name]
-      logtype: [machinename]: LCM:  [ End    Resource ] [name]
-      logtype: [machinename]: LCM:  [ End    Set      ]
-    EOH
-  end
-
-  let(:no_whatif_lcm_output) do
-    <<~EOH
-      Start-DscConfiguration : A parameter cannot be found\r\n that matches parameter name 'whatif'.
-      At line:1 char:123
-      + run-somecommand -whatif
-      +                        ~~~~~~~~
-          + CategoryInfo          : InvalidArgument: (:) [Start-DscConfiguration], ParameterBindingException
-          + FullyQualifiedErrorId : NamedParameterNotFound,SomeCompany.SomeAssembly.Commands.RunSomeCommand
-    EOH
-  end
-
-  let(:dsc_resource_import_failure_output) do
-    <<~EOH
-      PowerShell provider MSFT_xWebsite failed to execute Test-TargetResource functionality with error message: Please ensure that WebAdministration module is installed. + CategoryInfo : InvalidOperation: (:) [], CimException + FullyQualifiedErrorId : ProviderOperationExecutionFailure + PSComputerName : . PowerShell provider MSFT_xWebsite failed to execute Test-TargetResource functionality with error message: Please ensure that WebAdministration module is installed. + CategoryInfo : InvalidOperation: (:) [], CimException + FullyQualifiedErrorId : ProviderOperationExecutionFailure + PSComputerName : . The SendConfigurationApply function did not succeed. + CategoryInfo : NotSpecified: (root/Microsoft/...gurationManager:String) [], CimException + FullyQualifiedErrorId : MI RESULT 1 + PSComputerName : .
-    EOH
-  end
-
-  let(:powershell) do
-    double("Chef::PowerShell", errors: lcm_errors, error?: !lcm_errors.empty?, result: lcm_result)
-  end
-
-  describe "test_configuration method invocation" do
-    context "when interacting with the LCM using a PowerShell cmdlet" do
-      before(:each) do
-        allow(lcm).to receive(:run_configuration_cmdlet).and_return(powershell)
-        allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
-      end
-      context "that returns successfully" do
-        let(:lcm_result) { normal_lcm_output }
-        let(:lcm_errors) { [] }
-
-        it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
-          test_configuration_result = lcm.test_configuration("config")
-          expect(test_configuration_result.class).to be(Array)
-          expect(test_configuration_result.length).to be > 0
-          expect(Chef::Log).not_to receive(:warn)
-        end
-      end
-
-      context "when running on PowerShell version 5" do
-        let(:lcm_result) { normal_lcm_output }
-        let(:lcm_errors) { [] }
-
-        it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
-          allow(lcm).to receive(:ps_version_gte_5?).and_return(true)
-          test_configuration_result = lcm.test_configuration("config")
-          expect(test_configuration_result.class).to be(Array)
-          expect(test_configuration_result.length).to be > 0
-          expect(Chef::Log).not_to receive(:warn)
-        end
-      end
-
-      context "when running on PowerShell version less than 5" do
-        let(:lcm_result) { normal_lcm_output }
-        let(:lcm_errors) { [] }
-
-        it "successfully returns resource information for normally formatted output when cmdlet the cmdlet succeeds" do
-          allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
-          test_configuration_result = lcm.test_configuration("config")
-          expect(test_configuration_result.class).to be(Array)
-          expect(test_configuration_result.length).to be > 0
-          expect(Chef::Log).not_to receive(:warn)
-        end
-      end
-
-      context "#lcm_command" do
-        let(:common_command_prefix) { "$ProgressPreference = 'SilentlyContinue';" }
-        let(:ps4_base_command) { "#{common_command_prefix} Start-DscConfiguration -path tmp -wait -erroraction 'stop' -force" }
-        let(:lcm_command_ps4) { ps4_base_command + " -whatif; if (! $?) { exit 1 }" }
-        let(:lcm_command_ps5) { "#{common_command_prefix} Test-DscConfiguration -path tmp | format-list | Out-String" }
-        let(:lcm_result) { normal_lcm_output }
-        let(:lcm_errors) { [] }
-
-        it "successfully returns command when apply_configuration true" do
-          expect(lcm.send(:lcm_command, true)).to eq(ps4_base_command)
-        end
-
-        it "successfully returns command when PowerShell version 4" do
-          allow(lcm).to receive(:ps_version_gte_5?).and_return(false)
-          expect(lcm.send(:lcm_command, false)).to eq(lcm_command_ps4)
-        end
-
-        it "successfully returns command when PowerShell version 5" do
-          allow(lcm).to receive(:ps_version_gte_5?).and_return(true)
-          expect(lcm.send(:lcm_command, false)).to eq(lcm_command_ps5)
-        end
-      end
-
-      context "that fails due to missing what-if switch in DSC resource cmdlet implementation" do
-        let(:lcm_result) { "" }
-        let(:lcm_errors) { [no_whatif_lcm_output] }
-
-        it "returns true when passed to #whatif_not_supported?" do
-          expect(lcm.send(:whatif_not_supported?, no_whatif_lcm_output)).to be_truthy
-        end
-
-        it "returns a (possibly empty) array of ResourceInfo instances" do
-          expect(Chef::Log).to receive(:warn).at_least(:once)
-          expect(lcm).to receive(:whatif_not_supported?).and_call_original
-          test_configuration_result = nil
-          expect { test_configuration_result = lcm.test_configuration("config") }.not_to raise_error
-          expect(test_configuration_result.class).to be(Array)
-        end
-      end
-
-      context "that fails due to a DSC resource not being imported before StartDSCConfiguration -whatif is executed" do
-        let(:lcm_result) { "" }
-        let(:lcm_errors) { [dsc_resource_import_failure_output] }
-
-        it "logs a warning if the message is formatted as expected when a resource import failure occurs" do
-          expect(Chef::Log).to receive(:warn).at_least(:once)
-          expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
-          test_configuration_result = nil
-          expect { test_configuration_result = lcm.test_configuration("config") }.not_to raise_error
-        end
-
-        it "returns a (possibly empty) array of ResourceInfo instances" do
-          expect(Chef::Log).to receive(:warn).at_least(:once)
-          test_configuration_result = nil
-          expect { test_configuration_result = lcm.test_configuration("config") }.not_to raise_error
-          expect(test_configuration_result.class).to be(Array)
-        end
-      end
-
-      context "that fails due to an unknown PowerShell cmdlet error" do
-        let(:lcm_result) { "some output" }
-        let(:lcm_errors) { ["Abort, Retry, Fail?"] }
-
-        it "logs a warning" do
-          expect(Chef::Log).to receive(:warn).at_least(:once)
-          expect(lcm).to receive(:dsc_module_import_failure?).and_call_original
-          expect { lcm.test_configuration("config") }.not_to raise_error
-        end
-      end
-    end
-
-    it "identify a correctly formatted error message as a resource import failure" do
-      expect(lcm.send(:dsc_module_import_failure?, dsc_resource_import_failure_output)).to be(true)
-    end
-
-    it "does not identify an incorrectly formatted error message as a resource import failure" do
-      expect(lcm.send(:dsc_module_import_failure?, dsc_resource_import_failure_output.gsub("module", "gibberish"))).to be(false)
-    end
-
-    it "does not identify a message without a CimException reference as a resource import failure" do
-      expect(lcm.send(:dsc_module_import_failure?, dsc_resource_import_failure_output.gsub("CimException", "ArgumentException"))).to be(false)
-    end
-  end
-
-  describe "#run_configuration_cmdlet", :windows_powershell_dsc_only do
-    context "when invalid dsc script is given" do
-      it "raises exception" do
-        configuration_document = "invalid-config"
-        expect { lcm.send(:run_configuration_cmdlet, configuration_document, true) }.to raise_error(ChefPowerShell::PowerShellExceptions::PowerShellCommandFailed)
-      end
-    end
-  end
-end

data/spec/unit/util/dsc/resource_store.rb

@@ -1,78 +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/dsc/resource_store"
-
-describe Chef::Util::DSC::ResourceStore do
-  let(:resource_store) { Chef::Util::DSC::ResourceStore.new }
-  let(:resource_a) do
-    {
-    "ResourceType" => "AFoo",
-    "Name" => "Foo",
-    "Module" => { "Name" => "ModuleA" },
-    }
-  end
-
-  let(:resource_b) do
-    {
-    "ResourceType" => "BFoo",
-    "Name" => "Foo",
-    "Module" => { "Name" => "ModuleB" },
-    }
-  end
-
-  context "when resources are not cached" do
-    context "when calling #resources" do
-      it "returns an empty array" do
-        expect(resource_store.resources).to eql([])
-      end
-    end
-
-    context "when calling #find" do
-      it "returns an empty list if it cannot find any matching resources" do
-        expect(resource_store).to receive(:query_resource).and_return([])
-        expect(resource_store.find("foo")).to eql([])
-      end
-
-      it "returns the resource if it is found (comparisons are case insensitive)" do
-        expect(resource_store).to receive(:query_resource).and_return([resource_a])
-        expect(resource_store.find("foo")).to eql([resource_a])
-      end
-
-      it "returns multiple resources if they are found" do
-        expect(resource_store).to receive(:query_resource).and_return([resource_a, resource_b])
-        expect(resource_store.find("foo")).to include(resource_a, resource_b)
-      end
-
-      it "deduplicates resources by ResourceName" do
-        expect(resource_store).to receive(:query_resource).and_return([resource_a, resource_a])
-        resource_store.find("foo")
-        expect(resource_store.resources).to eq([resource_a])
-      end
-    end
-  end
-
-  context "when resources are cached" do
-    it "recalls resources from the cache if present" do
-      expect(resource_store).not_to receive(:query_resource)
-      expect(resource_store).to receive(:resources).and_return([resource_a])
-      resource_store.find("foo")
-    end
-  end
-end

data/spec/unit/util/editor_spec.rb

@@ -1,152 +0,0 @@
-require "spec_helper"
-require "chef/util/editor"
-
-describe Chef::Util::Editor do
-  describe "#initialize" do
-    it "takes an Enumerable of lines" do
-      editor = described_class.new(File.open(__FILE__))
-      expect(editor.lines).to be == IO.readlines(__FILE__)
-    end
-
-    it "makes a copy of an Array" do
-      array = []
-      editor = described_class.new(array)
-      expect(editor.lines).to_not be(array)
-    end
-  end
-
-  subject(:editor) { described_class.new(input_lines) }
-  let(:input_lines) { %w{one two two three} }
-
-  describe "#append_line_after" do
-    context "when there is no match" do
-      subject(:execute) { editor.append_line_after("missing", "new") }
-
-      it("returns the number of added lines") { is_expected.to eq(0) }
-      it "does not add any lines" do
-        expect { execute }.to_not change { editor.lines }
-      end
-    end
-
-    context "when there is a match" do
-      subject(:execute) { editor.append_line_after("two", "new") }
-
-      it("returns the number of added lines") { is_expected.to eq(2) }
-      it "adds a line after each match" do
-        execute
-        expect(editor.lines).to be == %w{one two new two new three}
-      end
-    end
-
-    it "matches a Regexp" do
-      expect(editor.append_line_after(/^ee/, "new")).to be == 0
-      expect(editor.append_line_after(/ee$/, "new")).to be == 1
-    end
-  end
-
-  describe "#append_line_if_missing" do
-    context "when there is no match" do
-      subject(:execute) { editor.append_line_if_missing("missing", "new") }
-
-      it("returns the number of added lines") { is_expected.to eq(1) }
-      it "adds a line to the end" do
-        execute
-        expect(editor.lines).to be == %w{one two two three new}
-      end
-    end
-
-    context "when there is a match" do
-      subject(:execute) { editor.append_line_if_missing("one", "new") }
-
-      it("returns the number of added lines") { is_expected.to eq(0) }
-      it "does not add any lines" do
-        expect { execute }.to_not change { editor.lines }
-      end
-    end
-
-    it "matches a Regexp" do
-      expect(editor.append_line_if_missing(/ee$/, "new")).to be == 0
-      expect(editor.append_line_if_missing(/^ee/, "new")).to be == 1
-    end
-  end
-
-  describe "#remove_lines" do
-    context "when there is no match" do
-      subject(:execute) { editor.remove_lines("missing") }
-
-      it("returns the number of removed lines") { is_expected.to eq(0) }
-      it "does not remove any lines" do
-        expect { execute }.to_not change { editor.lines }
-      end
-    end
-
-    context "when there is a match" do
-      subject(:execute) { editor.remove_lines("two") }
-
-      it("returns the number of removed lines") { is_expected.to eq(2) }
-      it "removes the matching lines" do
-        execute
-        expect(editor.lines).to be == %w{one three}
-      end
-    end
-
-    it "matches a Regexp" do
-      expect(editor.remove_lines(/^ee/)).to be == 0
-      expect(editor.remove_lines(/ee$/)).to be == 1
-    end
-  end
-
-  describe "#replace" do
-    context "when there is no match" do
-      subject(:execute) { editor.replace("missing", "new") }
-
-      it("returns the number of changed lines") { is_expected.to eq(0) }
-      it "does not change any lines" do
-        expect { execute }.to_not change { editor.lines }
-      end
-    end
-
-    context "when there is a match" do
-      subject(:execute) { editor.replace("two", "new") }
-
-      it("returns the number of changed lines") { is_expected.to eq(2) }
-      it "replaces the matching portions" do
-        execute
-        expect(editor.lines).to be == %w{one new new three}
-      end
-    end
-
-    it "matches a Regexp" do
-      expect(editor.replace(/^ee/, "new")).to be == 0
-      expect(editor.replace(/ee$/, "new")).to be == 1
-      expect(editor.lines).to be == %w{one two two thrnew}
-    end
-  end
-
-  describe "#replace_lines" do
-    context "when there is no match" do
-      subject(:execute) { editor.replace_lines("missing", "new") }
-
-      it("returns the number of changed lines") { is_expected.to eq(0) }
-      it "does not change any lines" do
-        expect { execute }.to_not change { editor.lines }
-      end
-    end
-
-    context "when there is a match" do
-      subject(:execute) { editor.replace_lines("two", "new") }
-
-      it("returns the number of replaced lines") { is_expected.to eq(2) }
-      it "replaces the matching line" do
-        execute
-        expect(editor.lines).to be == %w{one new new three}
-      end
-    end
-
-    it "matches a Regexp" do
-      expect(editor.replace_lines(/^ee/, "new")).to be == 0
-      expect(editor.replace_lines(/ee$/, "new")).to be == 1
-      expect(editor.lines).to be == %w{one two two new}
-    end
-  end
-end

data/spec/unit/util/file_edit_spec.rb

@@ -1,224 +0,0 @@
-#
-# Author:: Nuo Yan (<nuo@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 "spec_helper"
-require "tempfile"
-
-describe Chef::Util::FileEdit do
-
-  let(:starting_content) do
-    <<~EOF
-      127.0.0.1       localhost
-      255.255.255.255 broadcasthost
-      ::1             localhost
-      fe80::1%lo0     localhost
-    EOF
-  end
-
-  let(:localhost_replaced) do
-    <<~EOF
-      127.0.0.1       replacement
-      255.255.255.255 broadcasthost
-      ::1             replacement
-      fe80::1%lo0     replacement
-    EOF
-  end
-
-  let(:localhost_line_replaced) do
-    <<~EOF
-      replacement line
-      255.255.255.255 broadcasthost
-      replacement line
-      replacement line
-    EOF
-  end
-
-  let(:localhost_deleted) do
-    # sensitive to deliberate trailing whitespace
-    "127.0.0.1       \n255.255.255.255 broadcasthost\n::1             \nfe80::1%lo0     \n"
-  end
-
-  let(:localhost_line_deleted) do
-    <<~EOF
-      255.255.255.255 broadcasthost
-    EOF
-  end
-
-  let(:append_after_all_localhost) do
-    <<~EOF
-      127.0.0.1       localhost
-      new line inserted
-      255.255.255.255 broadcasthost
-      ::1             localhost
-      new line inserted
-      fe80::1%lo0     localhost
-      new line inserted
-    EOF
-  end
-
-  let(:append_after_content) do
-    <<~EOF
-      127.0.0.1       localhost
-      255.255.255.255 broadcasthost
-      ::1             localhost
-      fe80::1%lo0     localhost
-      new line inserted
-    EOF
-  end
-
-  let(:append_twice) do
-    <<~EOF
-      127.0.0.1       localhost
-      255.255.255.255 broadcasthost
-      ::1             localhost
-      fe80::1%lo0     localhost
-      once
-      twice
-    EOF
-  end
-
-  let(:target_file) do
-    f = Tempfile.open("file_edit_spec")
-    f.write(starting_content)
-    f.close
-    f
-  end
-
-  let(:fedit) { Chef::Util::FileEdit.new(target_file.path) }
-
-  after(:each) do
-    target_file.close!
-  end
-
-  describe "initialize" do
-    it "should create a new Chef::Util::FileEdit object" do
-      expect(fedit).to be_instance_of(Chef::Util::FileEdit)
-    end
-
-    it "should throw an exception if the input file does not exist" do
-      expect { Chef::Util::FileEdit.new("nonexistfile") }.to raise_error(ArgumentError)
-    end
-
-    # CHEF-5018: people have monkey patched this and it has accidentally been broken
-    it "should read the contents into memory as an array" do
-      expect(fedit.send(:editor).lines).to be_instance_of(Array)
-    end
-  end
-
-  describe "when the file is blank" do
-    let(:hosts_content) { "" }
-
-    it "should not throw an exception" do
-      expect { fedit }.not_to raise_error
-    end
-  end
-
-  def edited_file_contents
-    IO.read(target_file.path)
-  end
-
-  describe "search_file_replace" do
-    it "should accept regex passed in as a string (not Regexp object) and replace the match if there is one" do
-      fedit.search_file_replace("localhost", "replacement")
-      expect(fedit.unwritten_changes?).to be_truthy
-      fedit.write_file
-      expect(edited_file_contents).to eq(localhost_replaced)
-    end
-
-    it "should accept regex passed in as a Regexp object and replace the match if there is one" do
-      fedit.search_file_replace(/localhost/, "replacement")
-      expect(fedit.unwritten_changes?).to be_truthy
-      fedit.write_file
-      expect(edited_file_contents).to eq(localhost_replaced)
-    end
-
-    it "should do nothing if there isn't a match" do
-      fedit.search_file_replace(/pattern/, "replacement")
-      expect(fedit.unwritten_changes?).to be_falsey
-      fedit.write_file
-      expect(edited_file_contents).to eq(starting_content)
-    end
-  end
-
-  describe "search_file_replace_line" do
-    it "should search for match and replace the whole line" do
-      fedit.search_file_replace_line(/localhost/, "replacement line")
-      expect(fedit.unwritten_changes?).to be_truthy
-      fedit.write_file
-      expect(edited_file_contents).to eq(localhost_line_replaced)
-    end
-  end
-
-  describe "search_file_delete" do
-    it "should search for match and delete the match" do
-      fedit.search_file_delete(/localhost/)
-      expect(fedit.unwritten_changes?).to be_truthy
-      fedit.write_file
-      expect(edited_file_contents).to eq(localhost_deleted)
-    end
-  end
-
-  describe "search_file_delete_line" do
-    it "should search for match and delete the matching line" do
-      fedit.search_file_delete_line(/localhost/)
-      expect(fedit.unwritten_changes?).to be_truthy
-      fedit.write_file
-      expect(edited_file_contents).to eq(localhost_line_deleted)
-    end
-  end
-
-  describe "insert_line_after_match" do
-    it "should search for match and insert the given line after the matching line" do
-      fedit.insert_line_after_match(/localhost/, "new line inserted")
-      expect(fedit.unwritten_changes?).to be_truthy
-      fedit.write_file
-      expect(edited_file_contents).to eq(append_after_all_localhost)
-    end
-  end
-
-  describe "insert_line_if_no_match" do
-    it "should search for match and insert the given line if no line match" do
-      fedit.insert_line_if_no_match(/pattern/, "new line inserted")
-      expect(fedit.unwritten_changes?).to be_truthy
-      fedit.write_file
-      expect(edited_file_contents).to eq(append_after_content)
-    end
-
-    it "should do nothing if there is a match" do
-      fedit.insert_line_if_no_match(/localhost/, "replacement")
-      expect(fedit.unwritten_changes?).to be_falsey
-      fedit.write_file
-      expect(edited_file_contents).to eq(starting_content)
-    end
-
-    it "should work more than once" do
-      fedit.insert_line_if_no_match(/missing/, "once")
-      fedit.insert_line_if_no_match(/missing/, "twice")
-      fedit.write_file
-      expect(edited_file_contents).to eq(append_twice)
-    end
-  end
-
-  describe "file_edited" do
-    it "should return true if a file got edited" do
-      fedit.insert_line_if_no_match(/pattern/, "new line inserted")
-      fedit.write_file
-      expect(fedit.file_edited?).to be_truthy
-    end
-  end
-end

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

@@ -1,51 +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/ps_credential"
-
-describe Chef::Util::Powershell::PSCredential do
-  let(:username) { "foo" }
-  let(:password) { "ThIsIsThEpAsSwOrD" }
-
-  context "when username and password are provided" do
-    let(:ps_credential) { Chef::Util::Powershell::PSCredential.new(username, password) }
-    context "when calling to_psobject" do
-      it "should create the script to create a PSCredential when calling" do
-        allow(ps_credential).to receive(:encrypt).with(password).and_return("encrypted")
-        expect(ps_credential.to_psobject).to eq(
-          "New-Object System.Management.Automation.PSCredential("\
-              "'#{username}',('encrypted' | ConvertTo-SecureString))"
-        )
-      end
-    end
-
-    context "when inspect is called" do
-      it "should not contain the password" do
-        expect(ps_credential.inspect).not_to match(/#{password}/)
-      end
-    end
-
-    context "when to_text is called" do
-      it "should not contain the password" do
-        allow(ps_credential).to receive(:encrypt).with(password).and_return("encrypted")
-        expect(ps_credential.to_text).not_to match(/#{password}/)
-      end
-    end
-  end
-end