chef 12.4.0.rc.0-universal-mingw32

data/spec/unit/provider/directory_spec.rb

@@ -0,0 +1,188 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, 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 'ostruct'
+
+require 'spec_helper'
+require 'tmpdir'
+
+describe Chef::Provider::Directory do
+  before(:each) do
+    @new_resource = Chef::Resource::Directory.new(Dir.tmpdir)
+    if !windows?
+      @new_resource.owner(500)
+      @new_resource.group(500)
+      @new_resource.mode(0644)
+    end
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @directory = Chef::Provider::Directory.new(@new_resource, @run_context)
+  end
+
+
+  describe "scanning file security metadata on windows" do
+    before do
+    end
+
+    it "describes the directory's access rights" do
+      skip
+    end
+  end
+
+  describe "scanning file security metadata on unix" do
+    before do
+      allow(ChefConfig).to receive(:windows?).and_return(false)
+    end
+    let(:mock_stat) do
+      cstats = double("stats")
+      allow(cstats).to receive(:uid).and_return(500)
+      allow(cstats).to receive(:gid).and_return(500)
+      allow(cstats).to receive(:mode).and_return(0755)
+      cstats
+    end
+
+    it "describes the access mode as a String of octal integers" do
+      allow(File).to receive(:exists?).and_return(true)
+      expect(File).to receive(:stat).and_return(mock_stat)
+      @directory.load_current_resource
+      expect(@directory.current_resource.mode).to eq("0755")
+    end
+
+    context "when user and group are specified with UID/GID" do
+      it "describes the current owner and group as UID and GID" do
+        allow(File).to receive(:exists?).and_return(true)
+        expect(File).to receive(:stat).and_return(mock_stat)
+        @directory.load_current_resource
+        expect(@directory.current_resource.path).to eql(@new_resource.path)
+        expect(@directory.current_resource.owner).to eql(500)
+        expect(@directory.current_resource.group).to eql(500)
+      end
+    end
+
+    context "when user/group are specified with user/group names" do
+    end
+  end
+
+  # Unix only for now. While file security attribute reporting for windows is
+  # disabled, unix and windows differ in the number of exists? calls that are
+  # made by the provider.
+  it "should create a new directory on create, setting updated to true", :unix_only do
+    @new_resource.path "/tmp/foo"
+
+    expect(File).to receive(:exists?).at_least(:once).and_return(false)
+    expect(File).to receive(:directory?).with("/tmp").and_return(true)
+    expect(Dir).to receive(:mkdir).with(@new_resource.path).once.and_return(true)
+
+    expect(@directory).to receive(:do_acl_changes)
+    allow(@directory).to receive(:do_selinux)
+    @directory.run_action(:create)
+    expect(@directory.new_resource).to be_updated
+  end
+
+  it "should raise an exception if the parent directory does not exist and recursive is false" do
+    @new_resource.path "/tmp/some/dir"
+    @new_resource.recursive false
+    expect { @directory.run_action(:create) }.to raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+  end
+
+  # Unix only for now. While file security attribute reporting for windows is
+  # disabled, unix and windows differ in the number of exists? calls that are
+  # made by the provider.
+  it "should create a new directory when parent directory does not exist if recursive is true and permissions are correct", :unix_only do
+    @new_resource.path "/path/to/dir"
+    @new_resource.recursive true
+    expect(File).to receive(:exists?).with(@new_resource.path).ordered.and_return(false)
+
+    expect(File).to receive(:exists?).with('/path/to').ordered.and_return(false)
+    expect(File).to receive(:exists?).with('/path').ordered.and_return(true)
+    expect(Chef::FileAccessControl).to receive(:writable?).with('/path').ordered.and_return(true)
+    expect(File).to receive(:exists?).with(@new_resource.path).ordered.and_return(false)
+
+    expect(FileUtils).to receive(:mkdir_p).with(@new_resource.path).and_return(true)
+    expect(@directory).to receive(:do_acl_changes)
+    allow(@directory).to receive(:do_selinux)
+    @directory.run_action(:create)
+    expect(@new_resource).to be_updated
+  end
+
+
+  it "should raise an error when creating a directory when parent directory is a file" do
+    expect(File).to receive(:directory?).and_return(false)
+    expect(Dir).not_to receive(:mkdir).with(@new_resource.path)
+    expect { @directory.run_action(:create) }.to raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+    expect(@directory.new_resource).not_to be_updated
+  end
+
+  # Unix only for now. While file security attribute reporting for windows is
+  # disabled, unix and windows differ in the number of exists? calls that are
+  # made by the provider.
+  it "should not create the directory if it already exists", :unix_only do
+    stub_file_cstats
+    @new_resource.path "/tmp/foo"
+    expect(File).to receive(:directory?).at_least(:once).and_return(true)
+    expect(Chef::FileAccessControl).to receive(:writable?).with("/tmp").and_return(true)
+    expect(File).to receive(:exists?).at_least(:once).and_return(true)
+    expect(Dir).not_to receive(:mkdir).with(@new_resource.path)
+    expect(@directory).to receive(:do_acl_changes)
+    @directory.run_action(:create)
+  end
+
+  it "should delete the directory if it exists, and is writable with action_delete" do
+    expect(File).to receive(:directory?).and_return(true)
+    expect(Chef::FileAccessControl).to receive(:writable?).once.and_return(true)
+    expect(Dir).to receive(:delete).with(@new_resource.path).once.and_return(true)
+    @directory.run_action(:delete)
+  end
+
+  it "should raise an exception if it cannot delete the directory due to bad permissions" do
+    allow(File).to receive(:exists?).and_return(true)
+    allow(Chef::FileAccessControl).to receive(:writable?).and_return(false)
+    expect {  @directory.run_action(:delete) }.to raise_error(RuntimeError)
+  end
+
+  it "should take no action when deleting a target directory that does not exist" do
+    @new_resource.path "/an/invalid/path"
+    allow(File).to receive(:exists?).and_return(false)
+    expect(Dir).not_to receive(:delete).with(@new_resource.path)
+    @directory.run_action(:delete)
+    expect(@directory.new_resource).not_to be_updated
+  end
+
+  it "should raise an exception when deleting a directory when target directory is a file" do
+    stub_file_cstats
+    @new_resource.path "/an/invalid/path"
+    allow(File).to receive(:exists?).and_return(true)
+    expect(File).to receive(:directory?).and_return(false)
+    expect(Dir).not_to receive(:delete).with(@new_resource.path)
+    expect { @directory.run_action(:delete) }.to raise_error(RuntimeError)
+    expect(@directory.new_resource).not_to be_updated
+  end
+
+  def stub_file_cstats
+    cstats = double("stats")
+    allow(cstats).to receive(:uid).and_return(500)
+    allow(cstats).to receive(:gid).and_return(500)
+    allow(cstats).to receive(:mode).and_return(0755)
+    # File.stat is called in:
+    # - Chef::Provider::File.load_current_resource_attrs
+    # - Chef::ScanAccessControl via Chef::Provider::File.setup_acl
+    allow(File).to receive(:stat).and_return(cstats)
+  end
+end

data/spec/unit/provider/dsc_resource_spec.rb

@@ -0,0 +1,84 @@
+#
+# Author:: Jay Mundrawala (<jdm@chef.io>)
+#
+# 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 'spec_helper'
+
+describe Chef::Provider::DscResource do
+  let (:events) { Chef::EventDispatch::Dispatcher.new }
+  let (:run_context) { Chef::RunContext.new(node, {}, events) }
+  let (:resource) { Chef::Resource::DscResource.new("dscresource", run_context) }
+  let (:provider) do
+    Chef::Provider::DscResource.new(resource, run_context)
+  end
+
+  context 'when Powershell does not support Invoke-DscResource' do
+    let (:node) {
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = '4.0'
+      node
+    }
+
+    it 'raises a NoProviderAvailable exception' do
+      expect(provider).not_to receive(:meta_configuration)
+      expect{provider.run_action(:run)}.to raise_error(
+              Chef::Exceptions::NoProviderAvailable, /5\.0\.10018\.0/)
+    end
+  end
+
+  context 'when Powershell supports Invoke-DscResource' do
+    let (:node) {
+      node = Chef::Node.new
+      node.automatic[:languages][:powershell][:version] = '5.0.10018.0'
+      node
+    }
+
+    context 'when RefreshMode is not set to Disabled' do
+      let (:meta_configuration) { {'RefreshMode' => 'AnythingElse'}}
+
+      it 'raises an exception' do
+        expect(provider).to receive(:meta_configuration).and_return(
+                                                             meta_configuration)
+        expect { provider.run_action(:run) }.to raise_error(
+          Chef::Exceptions::NoProviderAvailable, /Disabled/)
+      end
+    end
+
+    context 'when RefreshMode is set to Disabled' do
+      let (:meta_configuration) { {'RefreshMode' => 'Disabled'}}
+
+      it 'does not update the resource if it is up to date' do
+        expect(provider).to receive(:meta_configuration).and_return(
+                                                             meta_configuration)
+        expect(provider).to receive(:test_resource).and_return(true)
+        provider.run_action(:run)
+        expect(resource).not_to be_updated
+      end
+
+      it 'converges the resource if it is not up to date' do
+        expect(provider).to receive(:meta_configuration).and_return(
+                                                             meta_configuration)
+        expect(provider).to receive(:test_resource).and_return(false)
+        expect(provider).to receive(:set_resource)
+        provider.run_action(:run)
+        expect(resource).to be_updated
+      end
+    end
+  end
+end

data/spec/unit/provider/dsc_script_spec.rb

@@ -0,0 +1,174 @@
+#
+# 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
+  context 'when DSC is available' 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
+        expect(provider.instance_variable_get('@resource_converged')).to be_truthy
+      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
+        expect(provider.instance_variable_get('@resource_converged')).to be_truthy
+      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
+        expect(provider.instance_variable_get('@resource_converged')).to be_falsey
+      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
+        expect(provider.instance_variable_get('@resource_converged')).to be_falsey
+      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
+        expect(provider.instance_variable_get('@resource_converged')).to be_truthy
+      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')
+        expect(generator).to 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')
+        expect(generator).to 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')
+        expect(generator).to receive(:configuration_document_from_script_code).with('', anything(), 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)
+        expect(resource).to 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)
+        expect(resource).not_to 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])
+        expect(provider.send(:generate_description)[1]).to 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])
+        expect(provider.send(:generate_description)[1]).not_to 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])
+        expect(provider.send(:generate_description)[1]).to match(/converge DSC resource resourcename by doing nothing/)
+      end
+    end
+  end
+
+  context 'when Dsc is not available' do
+    let (:node) { Chef::Node.new }
+    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) { Chef::Provider::DscScript.new(resource, run_context) }
+
+    describe 'action_run' do
+      ['1.0', '2.0', '3.0'].each do |version|
+        it "raises an exception for powershell version '#{version}'" do
+          node.automatic[:languages][:powershell][:version] = version
+
+          expect {
+            provider.run_action(:run)
+          }.to raise_error(Chef::Exceptions::NoProviderAvailable)
+        end
+      end
+
+      it 'raises an exception if Powershell is not present' do
+        expect {
+          provider.run_action(:run)
+        }.to raise_error(Chef::Exceptions::NoProviderAvailable)
+      end
+
+    end
+  end
+end
+

data/spec/unit/provider/env/windows_spec.rb

@@ -0,0 +1,103 @@
+#
+# Author:: Sander van Harmelen <svanharmelen@schubergphilis.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::Provider::Env::Windows, :windows_only do
+  let(:node) { Chef::Node.new }
+  let(:events) {Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+
+  context 'when environment variable is not PATH' do
+    let(:new_resource) {
+      new_resource = Chef::Resource::Env.new("CHEF_WINDOWS_ENV_TEST")
+      new_resource.value("foo")
+      new_resource
+    }
+    let(:provider) { 
+      provider = Chef::Provider::Env::Windows.new(new_resource, run_context) 
+      allow(provider).to receive(:env_obj).and_return(double('null object').as_null_object)
+      provider
+    }
+
+    describe "action_create" do
+      before do
+        ENV.delete('CHEF_WINDOWS_ENV_TEST')
+        provider.key_exists = false
+      end
+
+      it "should update the ruby ENV object when it creates the key" do
+        provider.action_create
+        expect(ENV['CHEF_WINDOWS_ENV_TEST']).to eql('foo')
+      end
+    end
+
+    describe "action_modify" do
+      before do
+        ENV['CHEF_WINDOWS_ENV_TEST'] = 'foo'
+      end
+
+      it "should update the ruby ENV object when it updates the value" do
+        expect(provider).to receive(:requires_modify_or_create?).and_return(true)
+        new_resource.value("foobar")
+        provider.action_modify
+        expect(ENV['CHEF_WINDOWS_ENV_TEST']).to eql('foobar')
+      end
+
+      describe "action_delete" do
+        before do
+          ENV['CHEF_WINDOWS_ENV_TEST'] = 'foo'
+        end
+
+        it "should update the ruby ENV object when it deletes the key" do
+          provider.action_delete
+          expect(ENV['CHEF_WINDOWS_ENV_TEST']).to eql(nil)
+        end
+      end
+    end
+  end
+
+  context 'when environment is PATH' do
+    describe "for PATH" do
+      let(:system_root) {'%SystemRoot%'}
+      let(:system_root_value) { 'D:\Windows' }
+      let(:new_resource) {
+        new_resource = Chef::Resource::Env.new('PATH')
+        new_resource.value(system_root)
+        new_resource
+      }
+      let(:provider) { 
+        provider = Chef::Provider::Env::Windows.new(new_resource, run_context) 
+        allow(provider).to receive(:env_obj).and_return(double('null object').as_null_object)
+        provider
+      }
+
+      before do
+        stub_const('ENV', {'PATH' => ''})
+      end
+
+      it "replaces Windows system variables" do
+        expect(provider).to receive(:requires_modify_or_create?).and_return(true)
+        expect(provider).to receive(:expand_path).with(system_root).and_return(system_root_value)
+        provider.action_modify
+        expect(ENV['PATH']).to eql(system_root_value)
+      end
+    end
+
+  end
+end