chef 14.0.190-universal-mingw32 → 14.0.202-universal-mingw32

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

@@ -1,193 +1,193 @@
-#
-# Author:: Jay Mundrawala <jmundrawala@chef.io>
-# Copyright:: Copyright 2014-2016, 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_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 command.downcase =~ /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/
-          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
+#
+# Author:: Jay Mundrawala <jmundrawala@chef.io>
+# Copyright:: Copyright 2014-2016, 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_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 command.downcase =~ /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/
+          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 +1,248 @@
-#
-# Author:: Bryan McLellan <btm@loftninjas.org>
-# Copyright:: Copyright 2014-2016, 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
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# Copyright:: Copyright 2014-2016, 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