chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/unit/provider/directory_spec.rb

@@ -48,31 +48,31 @@ describe Chef::Provider::Directory do
 
   describe "scanning file security metadata on unix" do
     before do
-      Chef::Platform.stub(:windows?).and_return(false)
+      allow(Chef::Platform).to receive(:windows?).and_return(false)
     end
     let(:mock_stat) do
       cstats = double("stats")
-      cstats.stub(:uid).and_return(500)
-      cstats.stub(:gid).and_return(500)
-      cstats.stub(:mode).and_return(0755)
+      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
-      File.stub(:exists?).and_return(true)
-      File.should_receive(:stat).and_return(mock_stat)
+      allow(File).to receive(:exists?).and_return(true)
+      expect(File).to receive(:stat).and_return(mock_stat)
       @directory.load_current_resource
-      @directory.current_resource.mode.should == "0755"
+      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
-        File.stub(:exists?).and_return(true)
-        File.should_receive(:stat).and_return(mock_stat)
+        allow(File).to receive(:exists?).and_return(true)
+        expect(File).to receive(:stat).and_return(mock_stat)
         @directory.load_current_resource
-        @directory.current_resource.path.should eql(@new_resource.path)
-        @directory.current_resource.owner.should eql(500)
-        @directory.current_resource.group.should eql(500)
+        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
 
@@ -86,20 +86,20 @@ describe Chef::Provider::Directory do
   it "should create a new directory on create, setting updated to true", :unix_only do
     @new_resource.path "/tmp/foo"
 
-    File.should_receive(:exists?).at_least(:once).and_return(false)
-    File.should_receive(:directory?).with("/tmp").and_return(true)
-    Dir.should_receive(:mkdir).with(@new_resource.path).once.and_return(true)
+    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)
 
-    @directory.should_receive(:do_acl_changes)
-    @directory.stub(:do_selinux)
+    expect(@directory).to receive(:do_acl_changes)
+    allow(@directory).to receive(:do_selinux)
     @directory.run_action(:create)
-    @directory.new_resource.should be_updated
+    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
-    lambda { @directory.run_action(:create) }.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
+    expect { @directory.run_action(:create) }.to raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
   end
 
   # Unix only for now. While file security attribute reporting for windows is
@@ -108,26 +108,26 @@ describe Chef::Provider::Directory do
   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
-    File.should_receive(:exists?).with(@new_resource.path).ordered.and_return(false)
+    expect(File).to receive(:exists?).with(@new_resource.path).ordered.and_return(false)
 
-    File.should_receive(:exists?).with('/path/to').ordered.and_return(false)
-    File.should_receive(:exists?).with('/path').ordered.and_return(true)
-    File.should_receive(:writable?).with('/path').ordered.and_return(true)
-    File.should_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(File).to receive(:writable?).with('/path').ordered.and_return(true)
+    expect(File).to receive(:exists?).with(@new_resource.path).ordered.and_return(false)
 
-    FileUtils.should_receive(:mkdir_p).with(@new_resource.path).and_return(true)
-    @directory.should_receive(:do_acl_changes)
-    @directory.stub(:do_selinux)
+    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)
-    @new_resource.should be_updated
+    expect(@new_resource).to be_updated
   end
 
 
   it "should raise an error when creating a directory when parent directory is a file" do
-    File.should_receive(:directory?).and_return(false)
-    Dir.should_not_receive(:mkdir).with(@new_resource.path)
-    lambda { @directory.run_action(:create) }.should raise_error(Chef::Exceptions::EnclosingDirectoryDoesNotExist)
-    @directory.new_resource.should_not be_updated
+    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
@@ -136,53 +136,53 @@ describe Chef::Provider::Directory do
   it "should not create the directory if it already exists", :unix_only do
     stub_file_cstats
     @new_resource.path "/tmp/foo"
-    File.should_receive(:directory?).at_least(:once).and_return(true)
-    File.should_receive(:writable?).with("/tmp").and_return(true)
-    File.should_receive(:exists?).at_least(:once).and_return(true)
-    Dir.should_not_receive(:mkdir).with(@new_resource.path)
-    @directory.should_receive(:do_acl_changes)
+    expect(File).to receive(:directory?).at_least(:once).and_return(true)
+    expect(File).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
-    File.should_receive(:directory?).and_return(true)
-    File.should_receive(:writable?).once.and_return(true)
-    Dir.should_receive(:delete).with(@new_resource.path).once.and_return(true)
+    expect(File).to receive(:directory?).and_return(true)
+    expect(File).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
-    File.stub(:exists?).and_return(true)
-    File.stub(:writable?).and_return(false)
-    lambda {  @directory.run_action(:delete) }.should raise_error(RuntimeError)
+    allow(File).to receive(:exists?).and_return(true)
+    allow(File).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"
-    File.stub(:exists?).and_return(false)
-    Dir.should_not_receive(:delete).with(@new_resource.path)
+    allow(File).to receive(:exists?).and_return(false)
+    expect(Dir).not_to receive(:delete).with(@new_resource.path)
     @directory.run_action(:delete)
-    @directory.new_resource.should_not be_updated
+    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"
-    File.stub(:exists?).and_return(true)
-    File.should_receive(:directory?).and_return(false)
-    Dir.should_not_receive(:delete).with(@new_resource.path)
-    lambda { @directory.run_action(:delete) }.should raise_error(RuntimeError)
-    @directory.new_resource.should_not be_updated
+    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")
-    cstats.stub(:uid).and_return(500)
-    cstats.stub(:gid).and_return(500)
-    cstats.stub(:mode).and_return(0755)
+    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
-    File.stub(:stat).and_return(cstats)
+    allow(File).to receive(:stat).and_return(cstats)
   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_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
+        expect(provider.instance_variable_get('@resource_converged')).to 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
+        expect(provider.instance_variable_get('@resource_converged')).to 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
+        expect(provider.instance_variable_get('@resource_converged')).to 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
+        expect(provider.instance_variable_get('@resource_converged')).to 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')
+        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())
+        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

@@ -19,49 +19,85 @@
 require 'spec_helper'
 
 describe Chef::Provider::Env::Windows, :windows_only do
-  before do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::Env.new("CHEF_WINDOWS_ENV_TEST")
-    @new_resource.value("foo")
-    @provider = Chef::Provider::Env::Windows.new(@new_resource, @run_context)
-    @provider.stub(:env_obj).and_return(double('null object').as_null_object)
-  end
+  let(:node) { Chef::Node.new }
+  let(:events) {Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, {}, events) }
 
-  describe "action_create" do
-    before do
-      ENV.delete('CHEF_WINDOWS_ENV_TEST')
-      @provider.key_exists = false
-    end
+  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
+    }
 
-    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_create" do
+      before do
+        ENV.delete('CHEF_WINDOWS_ENV_TEST')
+        provider.key_exists = false
+      end
 
-  describe "action_modify" do
-    before do
-      ENV['CHEF_WINDOWS_ENV_TEST'] = 'foo'
+      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
 
-    it "should update the ruby ENV object when it updates the value" do
-      @provider.should_receive(:compare_value).and_return(true)
-      @new_resource.value("foobar")
-      @provider.action_modify
-      expect(ENV['CHEF_WINDOWS_ENV_TEST']).to eql('foobar')
+    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
 
-  describe "action_delete" do
-    before do
-      ENV['CHEF_WINDOWS_ENV_TEST'] = 'foo'
-    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
+      }
 
-    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)
+      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