chef 18.8.11 → 18.8.46

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

@@ -1,272 +0,0 @@
-#
-# 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

@@ -1,248 +0,0 @@
-#
-# 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