chef 18.0.169-x64-mingw-ucrt

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

@@ -0,0 +1,272 @@
+#
+# Author:: Jay Mundrawala <jmundrawala@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/configuration_generator"
+
+describe Chef::Util::DSC::ConfigurationGenerator do
+  let(:conf_man) do
+    node = Chef::Node.new
+    Chef::Util::DSC::ConfigurationGenerator.new(node, "tmp")
+  end
+
+  describe "#validate_switch_name!" do
+    it "should not raise an error if a name contains all upper case letters" do
+      conf_man.send(:validate_switch_name!, "HELLO")
+    end
+
+    it "should not raise an error if the name contains all lower case letters" do
+      conf_man.send(:validate_switch_name!, "hello")
+    end
+
+    it "should not raise an error if no special characters are used except _" do
+      conf_man.send(:validate_switch_name!, "hello_world")
+    end
+
+    %w{! @ # $ % ^ & * & * ( ) - = + \{ \} . ? < > \\ /}.each do |sym|
+      it "raises an ArgumentError if configuration name contains #{sym}" do
+        expect do
+          conf_man.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 "escapes #{c}" do
+        expect(conf_man.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(conf_man.send(:escape_parameter_value, "stuff")).to eql("stuff")
+    end
+  end
+
+  describe "#escape_string_parameter_value" do
+    it "surrounds a string with ''" do
+      expect(conf_man.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
+        conf_man.send(:command_switches_string, { "foo" => "bar" })
+      end.to raise_error(ArgumentError)
+    end
+
+    it "does not allow invalid switch names" do
+      expect do
+        conf_man.send(:command_switches_string, { foo!: "bar" })
+      end.to raise_error(ArgumentError)
+    end
+
+    it "ignores switches with a false value" do
+      expect(conf_man.send(:command_switches_string, { foo: false })).to eql("")
+    end
+
+    it "should correctly handle a value type of string" do
+      expect(conf_man.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(conf_man.send(:command_switches_string, { foo: "" })).to eql("-foo ''")
+    end
+
+    it "should not quote integers" do
+      expect(conf_man.send(:command_switches_string, { foo: 1 })).to eql("-foo 1")
+    end
+
+    it "should not quote floats" do
+      expect(conf_man.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(conf_man.send(:command_switches_string, { foo: true })).to eql("-foo")
+    end
+  end
+
+  describe "#validate_configuration_name!" do
+    it "should not raise an error if a name contains all upper case letters" do
+      conf_man.send(:validate_configuration_name!, "HELLO")
+    end
+
+    it "should not raise an error if the name contains all lower case letters" do
+      conf_man.send(:validate_configuration_name!, "hello")
+    end
+
+    it "should not raise an error if no special characters are used except _" do
+      conf_man.send(:validate_configuration_name!, "hello_world")
+    end
+
+    %w{! @ # $ % ^ & * & * ( ) - = + \{ \} . ? < > \\ /}.each do |sym|
+      it "raises an Argument error if it configuration name contains #{sym}" do
+        expect do
+          conf_man.send(:validate_configuration_name!, "Hello#{sym}")
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#get_merged_configuration_flags" do
+    context "when strings are used as switches" do
+      it "should merge the hash if there are no restricted switches" do
+        merged = conf_man.send(:get_merged_configuration_flags!, { "flag" => "a" }, "hello")
+        expect(merged).to include(:flag)
+        expect(merged[:flag]).to eql("a")
+        expect(merged).to include(:outputpath)
+      end
+
+      it "should raise an ArgumentError if you try to override outputpath" do
+        expect do
+          conf_man.send(:get_merged_configuration_flags!, { "outputpath" => "a" }, "hello")
+        end.to raise_error(ArgumentError)
+      end
+
+      it "should be case insensitive for switches that are not allowed" do
+        expect do
+          conf_man.send(:get_merged_configuration_flags!, { "OutputPath" => "a" }, "hello")
+        end.to raise_error(ArgumentError)
+      end
+
+      it "should be case insensitive to switches that are allowed" do
+        merged = conf_man.send(:get_merged_configuration_flags!, { "FLAG" => "a" }, "hello")
+        expect(merged).to include(:flag)
+      end
+    end
+
+    context "when symbols are used as switches" do
+      it "should merge the hash if there are no restricted switches" do
+        merged = conf_man.send(:get_merged_configuration_flags!, { flag: "a" }, "hello")
+        expect(merged).to include(:flag)
+        expect(merged[:flag]).to eql("a")
+        expect(merged).to include(:outputpath)
+      end
+
+      it "should raise an ArgumentError if you try to override outputpath" do
+        expect do
+          conf_man.send(:get_merged_configuration_flags!, { outputpath: "a" }, "hello")
+        end.to raise_error(ArgumentError)
+      end
+
+      it "should be case insensitive for switches that are not allowed" do
+        expect do
+          conf_man.send(:get_merged_configuration_flags!, { OutputPath: "a" }, "hello")
+        end.to raise_error(ArgumentError)
+      end
+
+      it "should be case insensitive to switches that are allowed" do
+        merged = conf_man.send(:get_merged_configuration_flags!, { FLAG: "a" }, "hello")
+        expect(merged).to include(:flag)
+      end
+    end
+
+    context "when there are no flags" do
+      it "should supply an output path if configuration_flags is an empty hash" do
+        merged = conf_man.send(:get_merged_configuration_flags!, {}, "hello")
+        expect(merged).to include(:outputpath)
+        expect(merged.length).to eql(1)
+      end
+
+      it "should supply an output path if configuration_flags is an empty hash" do
+        merged = conf_man.send(:get_merged_configuration_flags!, nil, "hello")
+        expect(merged).to include(:outputpath)
+        expect(merged.length).to eql(1)
+      end
+    end
+
+    # What should happen if configuration flags contains duplicates?
+    # flagA => 'a', flaga => 'a'
+    # or
+    # flagA => 'a', flaga => 'b'
+    #
+  end
+
+  describe "#write_document_generation_script" do
+    let(:file_like_object) { double("file like object") }
+
+    it "should write the input to a file" do
+      allow(File).to receive(:open).and_yield(file_like_object)
+      allow(File).to receive(:join) do |a, b|
+        [a, b].join("++")
+      end
+      allow(file_like_object).to receive(:write)
+      conf_man.send(:write_document_generation_script, "file", "hello", {})
+      expect(file_like_object).to have_received(:write)
+    end
+  end
+
+  describe "#find_configuration_document" do
+    it "should find the mof file" do
+      # These tests seem way too implementation specific. Unfortunately, File and Dir
+      # need to be mocked because they are OS specific
+      allow(File).to receive(:join) do |a, b|
+        [a, b].join("++")
+      end
+
+      allow(Dir).to receive(:entries).with("tmp++hello") { ["f1", "f2", "hello.mof", "f3"] }
+      expect(conf_man.send(:find_configuration_document, "hello")).to eql("tmp++hello++hello.mof")
+    end
+
+    it "should return nil if the mof file is not found" do
+      allow(File).to receive(:join) do |a, b|
+        [a, b].join("++")
+      end
+      allow(Dir).to receive(:entries).with("tmp++hello") { %w{f1 f2 f3} }
+      expect(conf_man.send(:find_configuration_document, "hello")).to be_nil
+    end
+  end
+
+  describe "#configuration_code" do
+    it "should build dsc" do
+      dsc = conf_man.send(:configuration_code, "archive{}", "hello", {})
+      found_configuration = false
+      dsc.split(";").each do |command|
+        if /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/.match?(command.downcase)
+          found_configuration = true
+        end
+      end
+      expect(found_configuration).to be_truthy
+    end
+    context "with imports" do
+      it "should import all resources when a module has an empty list" do
+        dsc = conf_man.send(:configuration_code, "archive{}", "hello", { "FooModule" => [] })
+        expect(dsc).to match(/Import-DscResource -ModuleName FooModule\s*\n/)
+      end
+
+      it "should import all resources when a module has a list with *" do
+        dsc = conf_man.send(:configuration_code, "archive{}", "hello", { "FooModule" => ["FooResource", "*", "BarResource"] })
+        expect(dsc).to match(/Import-DscResource -ModuleName FooModule\s*\n/)
+      end
+
+      it "should import specific resources when a module has list without * that is not empty" do
+        dsc = conf_man.send(:configuration_code, "archive{}", "hello", { "FooModule" => %w{FooResource BarResource} })
+        expect(dsc).to match(/Import-DscResource -ModuleName FooModule -Name FooResource,BarResource/)
+      end
+
+      it "should import multiple modules with multiple import statements" do
+        dsc = conf_man.send(:configuration_code, "archive{}", "hello", { "FooModule" => %w{FooResource BarResource}, "BazModule" => [] })
+        expect(dsc).to match(/Import-DscResource -ModuleName FooModule -Name FooResource,BarResource/)
+        expect(dsc).to match(/Import-DscResource -ModuleName BazModule\s*\n/)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# 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/util/dsc/lcm_output_parser"
+
+describe Chef::Util::DSC::LocalConfigurationManager::Parser do
+  context "empty input parameter for WhatIfParser" do
+    it "raises an exception when there are no valid lines" do
+      str = <<-EOF
+
+      EOF
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+
+    it "raises an exception for a nil input" do
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil, false) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+  end
+
+  context "empty input parameter for TestDSCParser" do
+    it "raises an exception when there are no valid lines" do
+      str = <<-EOF
+
+      EOF
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+
+    it "raises an exception for a nil input" do
+      expect { Chef::Util::DSC::LocalConfigurationManager::Parser.parse(nil, true) }.to raise_error(Chef::Exceptions::LCMParser)
+    end
+  end
+
+  context "correctly formatted output from lcm for WhatIfParser" do
+    it "returns a single resource when only 1 logged with the correct name" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ] [name]
+        logtype: [machinename]: LCM:  [ End    Resource ] [name]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources.length).to eq(1)
+      expect(resources[0].name).to eq("[name]")
+    end
+
+    it "identifies when a resource changes the state of the system" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ] [name]
+        logtype: [machinename]: LCM:  [ Start  Set      ] [name]
+        logtype: [machinename]: LCM:  [ End    Set      ] [name]
+        logtype: [machinename]: LCM:  [ End    Resource ] [name]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources[0].changes_state?).to be_truthy
+    end
+
+    it "preserves the log provided for how the system changed the state" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ] [name]
+        logtype: [machinename]: LCM:  [ Start  Set      ] [name]
+        logtype: [machinename]:                           [message]
+        logtype: [machinename]: LCM:  [ End    Set      ] [name]
+        logtype: [machinename]: LCM:  [ End    Resource ] [name]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources[0].change_log).to match_array(["[name]", "[message]", "[name]"])
+    end
+
+    it "returns false for changes_state?" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ] [name]
+        logtype: [machinename]: LCM:  [ Skip   Set      ] [name]
+        logtype: [machinename]: LCM:  [ End    Resource ] [name]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources[0].changes_state?).to be_falsey
+    end
+
+    it "returns an empty array for change_log if changes_state? is false" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ] [name]
+        logtype: [machinename]: LCM:  [ Skip   Set      ] [name]
+        logtype: [machinename]: LCM:  [ End    Resource ] [name]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources[0].change_log).to be_empty
+    end
+  end
+
+  context "correctly formatted output from lcm for TestDSCParser" do
+    it "returns a single resource when only 1 logged with the correct name" do
+      str = <<~EOF
+        InDesiredState            : False
+        ResourcesInDesiredState   :
+        ResourcesNotInDesiredState: [name]
+        ReturnValue               : 0
+        PSComputerName            : .
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources.length).to eq(1)
+      expect(resources[0].name).to eq("[name]")
+    end
+
+    it "identifies when a resource changes the state of the system" do
+      str = <<~EOF
+        InDesiredState            : False
+        ResourcesInDesiredState   :
+        ResourcesNotInDesiredState: [name]
+        ReturnValue               : 0
+        PSComputerName            : .
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_truthy
+    end
+
+    it "returns false for changes_state?" do
+      str = <<~EOF
+        InDesiredState            : True
+        ResourcesInDesiredState   : [name]
+        ResourcesNotInDesiredState:
+        ReturnValue               : 0
+        PSComputerName            : .
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_falsey
+    end
+
+    it "returns an empty array for change_log if changes_state? is false" do
+      str = <<~EOF
+        InDesiredState            : True
+        ResourcesInDesiredState   : [name]
+        ResourcesNotInDesiredState:
+        ReturnValue               : 0
+        PSComputerName            : .
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].change_log).to be_empty
+    end
+  end
+
+  context "Incorrectly formatted output from LCM for WhatIfParser" do
+    it "allows missing [End Resource] when its the last one and still find all the resource" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
+        logtype: [machinename]: LCM:  [ Start  Test     ]
+        logtype: [machinename]: LCM:  [ End    Test     ]
+        logtype: [machinename]: LCM:  [ Skip   Set      ]
+        logtype: [machinename]: LCM:  [ End    Resource ]
+        logtype: [machinename]: LCM:  [ Start  Resource ]  [name2]
+        logtype: [machinename]: LCM:  [ Start  Test     ]
+        logtype: [machinename]: LCM:  [ End    Test     ]
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources[0].changes_state?).to be_falsey
+      expect(resources[1].changes_state?).to be_truthy
+    end
+
+    it "allow missing [End Resource] when its the first one and still find all the resource" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
+        logtype: [machinename]: LCM:  [ Start  Test     ]
+        logtype: [machinename]: LCM:  [ End    Test     ]
+        logtype: [machinename]: LCM:  [ Skip   Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ]  [name2]
+        logtype: [machinename]: LCM:  [ Start  Test     ]
+        logtype: [machinename]: LCM:  [ End    Test     ]
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+        logtype: [machinename]: LCM:  [ End    Resource ]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources[0].changes_state?).to be_falsey
+      expect(resources[1].changes_state?).to be_truthy
+    end
+
+    it "allows missing set and end resource and assume an unconverged resource in this case" do
+      str = <<~EOF
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ Start  Resource ]  [name]
+        logtype: [machinename]: LCM:  [ Start  Test     ]
+        logtype: [machinename]: LCM:  [ End    Test     ]
+        logtype: [machinename]: LCM:  [ Start  Resource ]  [name2]
+        logtype: [machinename]: LCM:  [ Start  Test     ]
+        logtype: [machinename]: LCM:  [ End    Test     ]
+        logtype: [machinename]: LCM:  [ Start  Set      ]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+        logtype: [machinename]: LCM:  [ End    Resource ]
+        logtype: [machinename]: LCM:  [ End    Set      ]
+      EOF
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, false)
+      expect(resources[0].changes_state?).to be_truthy
+      expect(resources[0].name).to eql("[name]")
+      expect(resources[1].changes_state?).to be_truthy
+      expect(resources[1].name).to eql("[name2]")
+    end
+  end
+
+  context "Incorrectly formatted output from LCM for TestDSCParser" do
+    it "allows missing [End Resource] when its the last one and still find all the resource" do
+      str = <<~EOF
+        InDesiredState            : True
+        ResourcesInDesiredState   :
+        ResourcesNotInDesiredState: [name]
+        ReturnValue               : 0
+        PSComputerName            : .
+        InDesiredState            : True
+        ResourcesInDesiredState   :
+        ResourcesNotInDesiredState: [name2]
+        ReturnValue               : 0
+        PSComputerName            : .
+      EOF
+
+      resources = Chef::Util::DSC::LocalConfigurationManager::Parser.parse(str, true)
+      expect(resources[0].changes_state?).to be_falsey
+    end
+  end
+end