chef 11.14.6-x86-mingw32 → 11.16.0-x86-mingw32

data/spec/spec_helper.rb

@@ -107,8 +107,11 @@ RSpec.configure do |config|
   config.filter_run_excluding :not_supported_on_win2k3 => true if windows_win2k3?
   config.filter_run_excluding :not_supported_on_solaris => true if solaris?
   config.filter_run_excluding :win2k3_only => true unless windows_win2k3?
+  config.filter_run_excluding :windows_2008r2_or_later => true unless windows_2008r2_or_later?
   config.filter_run_excluding :windows64_only => true unless windows64?
   config.filter_run_excluding :windows32_only => true unless windows32?
+  config.filter_run_excluding :windows_powershell_dsc_only => true unless windows_powershell_dsc?
+  config.filter_run_excluding :windows_powershell_no_dsc_only => true unless ! windows_powershell_dsc?
   config.filter_run_excluding :windows_domain_joined_only => true unless windows_domain_joined?
   config.filter_run_excluding :solaris_only => true unless solaris?
   config.filter_run_excluding :system_windows_service_gem_only => true unless system_windows_service_gem?

data/spec/support/platform_helpers.rb

@@ -43,6 +43,30 @@ def windows_win2k3?
   (host['version'] && host['version'].start_with?("5.2"))
 end
 
+def windows_2008r2_or_later?
+  return false unless windows?
+  wmi = WmiLite::Wmi.new
+  host = wmi.first_of('Win32_OperatingSystem')
+  version = host['version']
+  return false unless version
+  components = version.split('.').map do | component |
+    component.to_i
+  end
+  components.length >=2 && components[0] >= 6 && components[1] >= 1
+end
+
+def windows_powershell_dsc?
+  return false unless windows?
+  supports_dsc = false
+  begin
+    wmi = WmiLite::Wmi.new('root/microsoft/windows/desiredstateconfiguration')
+    lcm = wmi.query("SELECT * FROM meta_class WHERE __this ISA 'MSFT_DSCLocalConfigurationManager'")
+    supports_dsc = !! lcm
+  rescue WmiLite::WmiException
+  end
+  supports_dsc
+end
+
 def mac_osx_106?
   if File.exists? "/usr/bin/sw_vers"
     result = shell_out("/usr/bin/sw_vers")

data/spec/unit/platform/query_helpers_spec.rb

@@ -30,3 +30,26 @@ describe "Chef::Platform#windows_server_2003?" do
     expect { Thread.fork { Chef::Platform.windows_server_2003? }.join }.not_to raise_error
   end
 end
+
+describe 'Chef::Platform#supports_dsc?' do 
+  it 'returns false if powershell is not present' do
+    node = Chef::Node.new
+    Chef::Platform.supports_dsc?(node).should be_false
+  end
+
+  ['1.0', '2.0', '3.0'].each do |version|
+    it "returns false for Powershell #{version}" do
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = version
+      Chef::Platform.supports_dsc?(node).should be_false
+    end
+  end
+
+  ['4.0', '5.0'].each do |version|
+    it "returns true for Powershell #{version}" do
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = version
+      Chef::Platform.supports_dsc?(node).should be_true
+    end
+  end
+end

data/spec/unit/provider/dsc_script_spec.rb

@@ -0,0 +1,145 @@
+#
+# Author:: Jay Mundrawala (<jdm@getchef.com>)
+#
+# Copyright:: Copyright (c) 2014 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_info'
+require 'spec_helper'
+
+describe Chef::Provider::DscScript do
+  let (:node) {
+    node = Chef::Node.new
+    node.automatic[:languages][:powershell][:version] = '4.0'
+    node
+  }
+  let (:events) { Chef::EventDispatch::Dispatcher.new }
+  let (:run_context) { Chef::RunContext.new(node, {}, events) }
+  let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
+  let (:provider) do
+    Chef::Provider::DscScript.new(resource, run_context)
+  end
+
+  describe '#load_current_resource' do
+    it "describes the resource as converged if there were 0 DSC resources" do
+      allow(provider).to receive(:run_configuration).with(:test).and_return([])
+      provider.load_current_resource
+      provider.instance_variable_get('@resource_converged').should be_true
+    end
+
+    it "describes the resource as not converged if there is 1 DSC resources that is converged" do
+      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+      provider.load_current_resource
+      provider.instance_variable_get('@resource_converged').should be_true
+    end
+
+    it "describes the resource as not converged if there is 1 DSC resources that is not converged" do
+      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
+      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+      provider.load_current_resource
+      provider.instance_variable_get('@resource_converged').should be_false
+    end
+
+    it "describes the resource as not converged if there are any DSC resources that are not converged" do
+      dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
+      dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+
+      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
+      provider.load_current_resource
+      provider.instance_variable_get('@resource_converged').should be_false
+    end
+
+    it "describes the resource as converged if all DSC resources that are converged" do
+      dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+      dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
+
+      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
+      provider.load_current_resource
+      provider.instance_variable_get('@resource_converged').should be_true
+    end
+  end
+
+  describe '#generate_configuration_document' do
+    # I think integration tests should cover these cases
+
+    it 'uses configuration_document_from_script_path when a dsc script file is given' do
+      allow(provider).to receive(:load_current_resource)
+      resource.command("path_to_script")
+      generator = double('Chef::Util::DSC::ConfigurationGenerator')
+      generator.should_receive(:configuration_document_from_script_path)
+      allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+      provider.send(:generate_configuration_document, 'tmp', nil)
+    end
+
+    it 'uses configuration_document_from_script_code when a the dsc resource is given' do
+      allow(provider).to receive(:load_current_resource)
+      resource.code("ImADSCResource{}")
+      generator = double('Chef::Util::DSC::ConfigurationGenerator')
+      generator.should_receive(:configuration_document_from_script_code)
+      allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+      provider.send(:generate_configuration_document, 'tmp', nil)
+    end
+
+    it 'should noop if neither code or command are provided' do
+      allow(provider).to receive(:load_current_resource)
+      generator = double('Chef::Util::DSC::ConfigurationGenerator')
+      generator.should_receive(:configuration_document_from_script_code).with('', anything(), anything())
+      allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
+      provider.send(:generate_configuration_document, 'tmp', nil)
+    end
+  end
+
+  describe 'action_run' do
+    it 'should converge the script if it is not converged' do
+      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
+      allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
+      allow(provider).to receive(:run_configuration).with(:set)
+
+      provider.run_action(:run)
+      resource.should be_updated
+    end
+
+    it 'should not converge if the script is already converged' do
+      allow(provider).to receive(:run_configuration).with(:test).and_return([])
+      
+      provider.run_action(:run)
+      resource.should_not be_updated
+    end
+  end
+
+  describe '#generate_description' do
+    it 'removes the resource name from the beginning of any log line from the LCM' do
+      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
+      provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
+      provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing something/)
+    end
+
+    it 'ignores the last line' do
+      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
+      provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
+      provider.send(:generate_description)[1].should_not match(/lastline/)
+    end
+
+    it 'reports a dsc resource has not been changed if the LCM reported no change was required' do
+      dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', false, ['resourcename does nothing', 'lastline'])
+      provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
+      provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing nothing/)
+    end
+  end
+end
+

data/spec/unit/provider/user/dscl_spec.rb

@@ -376,6 +376,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30"
     let(:user_plist_file) { nil }
 
     before do
+      provider.should_receive(:shell_out).with("dscacheutil '-flushcache'")
       provider.should_receive(:shell_out).with("plutil -convert xml1 -o - /var/db/dslocal/nodes/Default/users/toor.plist") do
         if user_plist_file.nil?
           ShellCmdResult.new('Can not find the file', 'Sorry!!', 1)
@@ -715,7 +716,6 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
       provider.should_receive(:read_user_info)
       provider.should_receive(:dscl_set)
       provider.should_receive(:sleep).with(3)
-      provider.should_receive(:shell_out).with("dscacheutil '-flushcache'")
       provider.should_receive(:save_user_info)
       provider.set_password
     end
@@ -822,6 +822,7 @@ ea18e18b720e358e7fbe3cfbeaa561456f6ba008937a30")
 
   describe "when the user exists" do
     before do
+      provider.should_receive(:shell_out).with("dscacheutil '-flushcache'")
       provider.should_receive(:shell_out).with("plutil -convert xml1 -o - /var/db/dslocal/nodes/Default/users/toor.plist") do
         ShellCmdResult.new(File.read(File.join(CHEF_SPEC_DATA, "mac_users/10.9.plist.xml")), "", 0)
       end

data/spec/unit/resource/dsc_script_spec.rb

@@ -0,0 +1,127 @@
+#
+# Author:: Adam Edwards (<adamed@getchef.com>)
+# Copyright:: Copyright (c) 2014 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'
+
+describe Chef::Resource::DscScript do
+  let(:dsc_test_resource_name) { 'DSCTest' }
+
+  context 'when Powershell supports Dsc' do
+    let(:dsc_test_run_context) {
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = '4.0'
+      empty_events = Chef::EventDispatch::Dispatcher.new
+      Chef::RunContext.new(node, {}, empty_events)
+    }
+    let(:dsc_test_resource) {
+      Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context) 
+    }
+    let(:configuration_code) {'echo "This is supposed to create a configuration document."'}
+    let(:configuration_path) {'c:/myconfigs/formatc.ps1'}
+    let(:configuration_name) { 'formatme' }
+    let(:configuration_data) { '@{AllNodes = @( @{ NodeName = "localhost"; PSDscAllowPlainTextPassword = $true })}' }
+    let(:configuration_data_script) { 'c:/myconfigs/data/safedata.psd1' }
+
+    it "has a default action of `:run`" do
+      expect(dsc_test_resource.action).to eq(:run)
+    end
+
+    it "has an allowed_actions attribute with only the `:run` and `:nothing` attributes" do
+      expect(dsc_test_resource.allowed_actions.to_set).to eq([:run,:nothing].to_set)
+    end
+
+    it "allows the code attribute to be set" do
+      dsc_test_resource.code(configuration_code)
+      expect(dsc_test_resource.code).to eq(configuration_code)
+    end
+
+    it "allows the command attribute to be set" do
+      dsc_test_resource.command(configuration_path)
+      expect(dsc_test_resource.command).to eq(configuration_path)
+    end
+
+    it "allows the configuration_name attribute to be set" do
+      dsc_test_resource.configuration_name(configuration_name)
+      expect(dsc_test_resource.configuration_name).to eq(configuration_name)
+    end
+
+    it "allows the configuration_data attribute to be set" do
+      dsc_test_resource.configuration_data(configuration_data)
+      expect(dsc_test_resource.configuration_data).to eq(configuration_data)
+    end
+
+    it "allows the configuration_data_script attribute to be set" do
+      dsc_test_resource.configuration_data_script(configuration_data_script)
+      expect(dsc_test_resource.configuration_data_script).to eq(configuration_data_script)
+    end
+
+    it "raises an ArgumentError exception if an attempt is made to set the code attribute when the command attribute is already set" do
+      dsc_test_resource.command(configuration_path)
+      expect { dsc_test_resource.code(configuration_code) }.to raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError exception if an attempt is made to set the command attribute when the code attribute is already set" do
+      dsc_test_resource.code(configuration_code)
+      expect { dsc_test_resource.command(configuration_path) }.to raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError exception if an attempt is made to set the configuration_name attribute when the code attribute is already set" do
+      dsc_test_resource.code(configuration_code)
+      expect { dsc_test_resource.configuration_name(configuration_name) }.to raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError exception if an attempt is made to set the configuration_data attribute when the configuration_data_script attribute is already set" do
+      dsc_test_resource.configuration_data_script(configuration_data_script)
+      expect { dsc_test_resource.configuration_data(configuration_data) }.to raise_error(ArgumentError)
+    end
+
+    it "raises an ArgumentError exception if an attempt is made to set the configuration_data_script attribute when the configuration_data attribute is already set" do
+      dsc_test_resource.configuration_data(configuration_data)
+      expect { dsc_test_resource.configuration_data_script(configuration_data_script) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when Powershell does not supported Dsc' do
+    ['1.0', '2.0', '3.0'].each do |version|
+      it "raises an exception for powershell version '#{version}'" do
+        node = Chef::Node.new
+        node.automatic[:languages][:powershell][:version] = version
+        empty_events = Chef::EventDispatch::Dispatcher.new
+        dsc_test_run_context = Chef::RunContext.new(node, {}, empty_events)
+
+        expect {
+          Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context)
+        }.to raise_error(Chef::Exceptions::NoProviderAvailable)
+      end
+    end
+  end
+
+  context 'when Powershell is not present' do
+    let (:dsc_test_run_context) {
+      node = Chef::Node.new
+      empty_events = Chef::EventDispatch::Dispatcher.new
+      dsc_test_run_context = Chef::RunContext.new(node, {}, empty_events)
+    }
+
+    it 'raises an exception if powershell is not present' do
+        expect {
+          Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context)
+        }.to raise_error(Chef::Exceptions::NoProviderAvailable)
+      end
+  end
+end

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

@@ -0,0 +1,171 @@
+#
+# Author:: Jay Mundrawala <jmundrawala@getchef.com>
+# Copyright:: Copyright (c) 2014 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 {
+          conf_man.send(:validate_configuration_name!, "Hello#{sym}")
+        }.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')
+        merged.should include(:flag)
+        merged[:flag].should eql('a')
+        merged.should include(:outputpath)
+      end
+
+      it 'should raise an ArgumentError if you try to override outputpath' do
+        expect {
+          conf_man.send(:get_merged_configuration_flags!, {'outputpath' => 'a'}, 'hello')
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'should be case insensitive for switches that are not allowed' do
+        expect {
+          conf_man.send(:get_merged_configuration_flags!, {'OutputPath' => 'a'}, 'hello')
+        }.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')
+        merged.should 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')
+        merged.should include(:flag)
+        merged[:flag].should eql('a')
+        merged.should include(:outputpath)
+      end
+
+      it 'should raise an ArgumentError if you try to override outputpath' do
+        expect {
+          conf_man.send(:get_merged_configuration_flags!, {:outputpath => 'a'}, 'hello')
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'should be case insensitive for switches that are not allowed' do
+        expect {
+          conf_man.send(:get_merged_configuration_flags!, {:OutputPath => 'a'}, 'hello')
+        }.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')
+        merged.should 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')
+        merged.should include(:outputpath)
+        merged.length.should 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')
+        merged.should include(:outputpath)
+        merged.length.should 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. Unfortunatly, 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") {['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_true
+    end
+  end
+end