chef 12.0.3 → 12.1.0.rc.0

data/spec/functional/win32/security_spec.rb

@@ -23,7 +23,7 @@ end
 
 describe 'Chef::Win32::Security', :windows_only do
   it "has_admin_privileges? returns true when running as admin" do
-    Chef::ReservedNames::Win32::Security.has_admin_privileges?.should == true
+    expect(Chef::ReservedNames::Win32::Security.has_admin_privileges?).to eq(true)
   end
 
   # We've done some investigation adding a negative test and it turned
@@ -32,6 +32,69 @@ describe 'Chef::Win32::Security', :windows_only do
   #
   # TODO - Add negative tests once mixlib-shellout has user support
   it "has_admin_privileges? returns false when running as non-admin" do
-    pending "requires user support in mixlib-shellout"
+    skip "requires user support in mixlib-shellout"
+  end
+
+  describe 'get_file_security' do
+    it 'should return a security descriptor when called with a path that exists' do
+      security_descriptor = Chef::ReservedNames::Win32::Security.get_file_security(
+        "C:\\Program Files")
+      # Make sure the security descriptor works
+      expect(security_descriptor.dacl_present?).to be true
+    end
+  end
+
+  describe 'access_check' do
+    let(:security_descriptor) {
+      Chef::ReservedNames::Win32::Security.get_file_security(
+        "C:\\Program Files")
+    }
+
+    let(:token_rights) { Chef::ReservedNames::Win32::Security::TOKEN_ALL_ACCESS }
+
+    let(:token) {
+      Chef::ReservedNames::Win32::Security.open_process_token(
+        Chef::ReservedNames::Win32::Process.get_current_process,
+        token_rights).duplicate_token(:SecurityImpersonation)
+    }
+
+    let(:mapping) {
+      mapping = Chef::ReservedNames::Win32::Security::GENERIC_MAPPING.new
+      mapping[:GenericRead] = Chef::ReservedNames::Win32::Security::FILE_GENERIC_READ
+      mapping[:GenericWrite] = Chef::ReservedNames::Win32::Security::FILE_GENERIC_WRITE
+      mapping[:GenericExecute] = Chef::ReservedNames::Win32::Security::FILE_GENERIC_EXECUTE
+      mapping[:GenericAll] = Chef::ReservedNames::Win32::Security::FILE_ALL_ACCESS
+      mapping
+    }
+
+    let(:desired_access) { Chef::ReservedNames::Win32::Security::FILE_GENERIC_READ }
+
+    it 'should check if the provided token has the desired access' do
+      expect(Chef::ReservedNames::Win32::Security.access_check(security_descriptor, 
+                     token, desired_access, mapping)).to be true
+    end
+  end
+
+  describe 'Chef::Win32::Security::Token' do
+    let(:token) {
+      Chef::ReservedNames::Win32::Security.open_process_token(
+        Chef::ReservedNames::Win32::Process.get_current_process,
+        token_rights)
+    }
+    context 'with all rights' do
+      let(:token_rights) { Chef::ReservedNames::Win32::Security::TOKEN_ALL_ACCESS }
+
+      it 'can duplicate a token' do
+        expect{ token.duplicate_token(:SecurityImpersonation) }.not_to raise_error
+      end
+    end
+
+    context 'with read only rights' do
+      let(:token_rights) { Chef::ReservedNames::Win32::Security::TOKEN_READ }
+
+      it 'raises an exception when trying to duplicate' do
+        expect{ token.duplicate_token(:SecurityImpersonation) }.to raise_error(Chef::Exceptions::Win32APIError)
+      end
+    end
   end
 end

data/spec/functional/win32/service_manager_spec.rb

@@ -24,7 +24,7 @@ end
 #
 # ATTENTION:
 # This test creates a windows service for testing purposes and runs it
-# as Local System on windows boxes.
+# as Local System (or an otherwise specified user) on windows boxes.
 # This test will fail if you run the tests inside a Windows VM by
 # sharing the code from your host since Local System account by
 # default can't see the mounted partitions.
@@ -35,65 +35,11 @@ end
 
 describe "Chef::Application::WindowsServiceManager", :windows_only, :system_windows_service_gem_only do
 
-  # Some helper methods.
-
-  def test_service_exists?
-    ::Win32::Service.exists?("spec-service")
-  end
-
-  def test_service_state
-    ::Win32::Service.status("spec-service").current_state
-  end
-
-  def service_manager
-    Chef::Application::WindowsServiceManager.new(test_service)
-  end
-
-  def cleanup
-    # Uninstall if the test service is installed.
-    if test_service_exists?
-
-      # We can only uninstall when the service is stopped.
-      if test_service_state != "stopped"
-        ::Win32::Service.send("stop", "spec-service")
-        while test_service_state != "stopped"
-          sleep 1
-        end
-      end
-
-      ::Win32::Service.delete("spec-service")
-    end
-
-    # Delete the test_service_file if it exists
-    if File.exists?(test_service_file)
-      File.delete(test_service_file)
-    end
-
-  end
-
-
-  # Definition for the test-service
-
-  let(:test_service) {
-    {
-      :service_name => "spec-service",
-      :service_display_name => "Spec Test Service",
-      :service_description => "Service for testing Chef::Application::WindowsServiceManager.",
-      :service_file_path => File.expand_path(File.join(File.dirname(__FILE__), '../../support/platforms/win32/spec_service.rb'))
-    }
-  }
-
-  # Test service creates a file for us to verify that it is running.
-  # Since our test service is running as Local System we should look
-  # for the file it creates under SYSTEM temp directory
-
-  let(:test_service_file) {
-    "#{ENV['SystemDrive']}\\windows\\temp\\spec_service_file"
-  }
+  include_context "using Win32::Service"
 
   context "with invalid service definition" do
     it "throws an error when initialized with no service definition" do
-      lambda { Chef::Application::WindowsServiceManager.new(nil) }.should raise_error(ArgumentError)
+      expect { Chef::Application::WindowsServiceManager.new(nil) }.to raise_error(ArgumentError)
     end
 
     it "throws an error with required missing options" do
@@ -101,7 +47,7 @@ describe "Chef::Application::WindowsServiceManager", :windows_only, :system_wind
         service_def = test_service.dup
         service_def.delete(key)
 
-        lambda { Chef::Application::WindowsServiceManager.new(service_def) }.should raise_error(ArgumentError)
+        expect { Chef::Application::WindowsServiceManager.new(service_def) }.to raise_error(ArgumentError)
       end
     end
   end
@@ -111,7 +57,7 @@ describe "Chef::Application::WindowsServiceManager", :windows_only, :system_wind
       @service_manager_output = [ ]
       # Uncomment below lines to debug this test
       # original_puts = $stdout.method(:puts)
-      $stdout.stub(:puts) do |message|
+      allow($stdout).to receive(:puts) do |message|
         @service_manager_output << message
         # original_puts.call(message)
       end
@@ -125,19 +71,19 @@ describe "Chef::Application::WindowsServiceManager", :windows_only, :system_wind
       it "default => should say service don't exist" do
         service_manager.run
 
-        @service_manager_output.grep(/doesn't exist on the system/).length.should > 0
+        expect(@service_manager_output.grep(/doesn't exist on the system/).length).to be > 0
       end
 
       it "install => should install the service" do
         service_manager.run(["-a", "install"])
 
-        test_service_exists?.should be_true
+        expect(test_service_exists?).to be_truthy
       end
 
       it "other actions => should say service doesn't exist" do
         ["delete", "start", "stop", "pause", "resume", "uninstall"].each do |action|
           service_manager.run(["-a", action])
-          @service_manager_output.grep(/doesn't exist on the system/).length.should > 0
+          expect(@service_manager_output.grep(/doesn't exist on the system/).length).to be > 0
           @service_manager_output = [ ]
         end
       end
@@ -150,47 +96,47 @@ describe "Chef::Application::WindowsServiceManager", :windows_only, :system_wind
 
       it "should have an own-process, non-interactive type" do
         status = ::Win32::Service.status("spec-service")
-        status[:service_type].should == "own process"
-        status[:interactive].should be_false
+        expect(status[:service_type]).to eq("own process")
+        expect(status[:interactive]).to be_falsey
       end
 
       it "install => should say service already exists" do
           service_manager.run(["-a", "install"])
-          @service_manager_output.grep(/already exists/).length.should > 0
+          expect(@service_manager_output.grep(/already exists/).length).to be > 0
       end
 
       context "and service is stopped" do
         ["delete", "uninstall"].each do |action|
           it "#{action} => should remove the service", :volatile do
             service_manager.run(["-a", action])
-            test_service_exists?.should be_false
+            expect(test_service_exists?).to be_falsey
           end
         end
 
         it "default, status => should say service is stopped" do
           service_manager.run([ ])
-          @service_manager_output.grep(/stopped/).length.should > 0
+          expect(@service_manager_output.grep(/stopped/).length).to be > 0
           @service_manager_output = [ ]
 
           service_manager.run(["-a", "status"])
-          @service_manager_output.grep(/stopped/).length.should > 0
+          expect(@service_manager_output.grep(/stopped/).length).to be > 0
         end
 
         it "start should start the service", :volatile do
           service_manager.run(["-a", "start"])
-          test_service_state.should == "running"
-          File.exists?(test_service_file).should be_true
+          expect(test_service_state).to eq("running")
+          expect(File.exists?(test_service_file)).to be_truthy
         end
 
         it "stop should not affect the service" do
           service_manager.run(["-a", "stop"])
-          test_service_state.should == "stopped"
+          expect(test_service_state).to eq("stopped")
         end
 
 
         ["pause", "resume"].each do |action|
           it "#{action} => should raise error" do
-            lambda {service_manager.run(["-a", action])}.should raise_error(::Win32::Service::Error)
+            expect { service_manager.run(["-a", action]) }.to raise_error(SystemCallError)
           end
         end
 
@@ -202,32 +148,32 @@ describe "Chef::Application::WindowsServiceManager", :windows_only, :system_wind
           ["delete", "uninstall"].each do |action|
             it "#{action} => should remove the service", :volatile do
               service_manager.run(["-a", action])
-              test_service_exists?.should be_false
+              expect(test_service_exists?).to be_falsey
             end
           end
 
           it "default, status => should say service is running" do
             service_manager.run([ ])
-            @service_manager_output.grep(/running/).length.should > 0
+            expect(@service_manager_output.grep(/running/).length).to be > 0
             @service_manager_output = [ ]
 
             service_manager.run(["-a", "status"])
-            @service_manager_output.grep(/running/).length.should > 0
+            expect(@service_manager_output.grep(/running/).length).to be > 0
           end
 
           it "stop should stop the service" do
             service_manager.run(["-a", "stop"])
-            test_service_state.should == "stopped"
+            expect(test_service_state).to eq("stopped")
           end
 
           it "pause should pause the service" do
             service_manager.run(["-a", "pause"])
-            test_service_state.should == "paused"
+            expect(test_service_state).to eq("paused")
           end
 
           it "resume should have no affect" do
             service_manager.run(["-a", "resume"])
-            test_service_state.should == "running"
+            expect(test_service_state).to eq("running")
           end
         end
 
@@ -241,31 +187,31 @@ describe "Chef::Application::WindowsServiceManager", :windows_only, :system_wind
           actions.each do |action|
             it "#{action} => should remove the service" do
               service_manager.run(["-a", action])
-              test_service_exists?.should be_false
+              expect(test_service_exists?).to be_falsey
             end
           end
 
           it "default, status => should say service is paused" do
             service_manager.run([ ])
-            @service_manager_output.grep(/paused/).length.should > 0
+            expect(@service_manager_output.grep(/paused/).length).to be > 0
             @service_manager_output = [ ]
 
             service_manager.run(["-a", "status"])
-            @service_manager_output.grep(/paused/).length.should > 0
+            expect(@service_manager_output.grep(/paused/).length).to be > 0
           end
 
           it "stop should stop the service" do
             service_manager.run(["-a", "stop"])
-            test_service_state.should == "stopped"
+            expect(test_service_state).to eq("stopped")
           end
 
           it "pause should not affect the service" do
             service_manager.run(["-a", "pause"])
-            test_service_state.should == "paused"
+            expect(test_service_state).to eq("paused")
           end
 
           it "start should raise an error" do
-            lambda {service_manager.run(["-a", "start"])}.should raise_error(::Win32::Service::Error)
+            expect {service_manager.run(["-a", "start"])}.to raise_error(::Win32::Service::Error)
           end
 
         end

data/spec/functional/win32/versions_spec.rb

@@ -62,8 +62,8 @@ describe "Chef::ReservedNames::Win32::Version", :windows_only, :not_supported_on
     it "should have have one method for each marketing version" do
       versions = 0
       for_each_windows_version { versions += 1 }
-      versions.should > 0
-      versions.should == Chef::ReservedNames::Win32::Version::WIN_VERSIONS.length
+      expect(versions).to be > 0
+      expect(versions).to eq(Chef::ReservedNames::Win32::Version::WIN_VERSIONS.length)
     end
 
     it "should only contain version methods with legal method names" do
@@ -71,8 +71,8 @@ describe "Chef::ReservedNames::Win32::Version", :windows_only, :not_supported_on
 
       for_each_windows_version do |method_name|
         method_match = method_name_pattern.match(method_name.to_s)
-        method_match.should_not be_nil
-        method_name.to_s.should == method_match[0]
+        expect(method_match).not_to be_nil
+        expect(method_name.to_s).to eq(method_match[0])
       end
     end
 
@@ -81,7 +81,7 @@ describe "Chef::ReservedNames::Win32::Version", :windows_only, :not_supported_on
       for_each_windows_version do |method_name|
         true_versions += 1 if @version.send(method_name)
       end
-      true_versions.should == 1
+      expect(true_versions).to eq(1)
     end
 
     it "should successfully execute all version methods" do
@@ -91,7 +91,7 @@ describe "Chef::ReservedNames::Win32::Version", :windows_only, :not_supported_on
 
   context "Windows Operating System version" do
     it "should match the version from WMI" do
-      @current_os_version.should include(@version.marketing_name)
+      expect(@current_os_version).to include(@version.marketing_name)
     end
   end
 

data/spec/integration/client/client_spec.rb

@@ -1,5 +1,34 @@
 require 'support/shared/integration/integration_helper'
 require 'chef/mixin/shell_out'
+require 'tiny_server'
+require 'tmpdir'
+
+def recipes_filename
+  File.join(CHEF_SPEC_DATA, 'recipes.tgz')
+end
+
+def start_tiny_server(server_opts={})
+  recipes_size = File::Stat.new(recipes_filename).size
+  @server = TinyServer::Manager.new(server_opts)
+  @server.start
+    @api = TinyServer::API.instance
+  @api.clear
+  #
+  # trivial endpoints
+  #
+  # just a normal file
+  # (expected_content should be uncompressed)
+  @api.get("/recipes.tgz", 200) {
+    File.open(recipes_filename, "rb") do |f|
+      f.read
+    end
+  }
+end
+
+def stop_tiny_server
+  @server.stop
+  @server = @api = nil
+end
 
 describe "chef-client" do
   include IntegrationSupport
@@ -44,7 +73,7 @@ EOM
 
       it 'should fail when cwd is below high above and paths are not specified' do
         result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", :cwd => File.expand_path('..', path_to('')))
-        result.exitstatus.should == 1
+        expect(result.exitstatus).to eq(1)
       end
     end
 
@@ -54,7 +83,7 @@ EOM
       it 'should load .chef/knife.rb when -z is specified' do
         result = shell_out("#{chef_client} -z -o 'x::default'", :cwd => path_to(''))
         # FATAL: Configuration error NoMethodError: undefined method `xxx' for nil:NilClass
-        result.stdout.should include("xxx")
+        expect(result.stdout).to include("xxx")
       end
 
     end
@@ -135,8 +164,8 @@ EOM
         result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" #{path_to('arbitrary.rb')} #{path_to('arbitrary2.rb')}", :cwd => chef_dir)
         result.error!
 
-        IO.read(path_to('tempfile.txt')).should == '1'
-        IO.read(path_to('tempfile2.txt')).should == '2'
+        expect(IO.read(path_to('tempfile.txt'))).to eq('1')
+        expect(IO.read(path_to('tempfile2.txt'))).to eq('2')
       end
 
       it "should run recipes specified as relative paths directly on the command line" do
@@ -155,7 +184,7 @@ EOM
         result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" arbitrary.rb", :cwd => path_to(''))
         result.error!
 
-        IO.read(path_to('tempfile.txt')).should == '1'
+        expect(IO.read(path_to('tempfile.txt'))).to eq('1')
       end
 
       it "should run recipes specified directly on the command line AFTER recipes in the run list" do
@@ -179,7 +208,7 @@ EOM
         result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o x::constant_definition arbitrary.rb", :cwd => path_to(''))
         result.error!
 
-        IO.read(path_to('tempfile.txt')).should == '1'
+        expect(IO.read(path_to('tempfile.txt'))).to eq('1')
       end
 
     end
@@ -211,7 +240,7 @@ cookbook_path "#{path_to('cookbooks')}"
 EOM
 
       result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --local-mode", :cwd => chef_dir)
-      result.stdout.should_not include("SSL validation of HTTPS requests is disabled.")
+      expect(result.stdout).not_to include("SSL validation of HTTPS requests is disabled.")
       result.error!
     end
 
@@ -232,11 +261,75 @@ cookbook_path "#{path_to('cookbooks')}"
 EOM
 
       result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -r 'x::default' -z", :cwd => chef_dir)
-      result.stdout.should_not include("Overridden Run List")
-      result.stdout.should include("Run List is [recipe[x::default]]")
+      expect(result.stdout).not_to include("Overridden Run List")
+      expect(result.stdout).to include("Run List is [recipe[x::default]]")
       #puts result.stdout
       result.error!
     end
 
   end
+
+  when_the_repository "has a cookbook with only an audit recipe" do
+
+    before do
+      file 'config/client.rb', <<EOM
+local_mode true
+cookbook_path "#{path_to('cookbooks')}"
+audit_mode :enabled
+EOM
+    end
+
+    it "should exit with a zero code when there is not an audit failure" do
+      file 'cookbooks/audit_test/recipes/succeed.rb', <<-RECIPE
+control_group "control group without top level control" do
+  it "should succeed" do
+    expect(2 - 2).to eq(0)
+  end
+end
+      RECIPE
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'audit_test::succeed'", :cwd => chef_dir)
+      expect(result.error?).to be_falsey
+      expect(result.stdout).to include("Successfully executed all `control_group` blocks and contained examples")
+    end
+
+    it "should exit with a non-zero code when there is an audit failure" do
+      file 'cookbooks/audit_test/recipes/fail.rb', <<-RECIPE
+control_group "control group without top level control" do
+  it "should fail" do
+    expect(2 - 2).to eq(1)
+  end
+end
+      RECIPE
+
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'audit_test::fail'", :cwd => chef_dir)
+      expect(result.error?).to be_truthy
+      expect(result.stdout).to include("Failure/Error: expect(2 - 2).to eq(1)")
+    end
+  end
+
+  context "when using recipe-url" do
+    before(:all) do
+      start_tiny_server
+    end
+
+    after(:all) do
+      stop_tiny_server
+    end
+
+    let(:tmp_dir) { Dir.mktmpdir("recipe-url") }
+
+    it "should complete with success when passed -z and --recipe-url" do
+      file 'config/client.rb', <<EOM
+chef_repo_path "#{tmp_dir}"
+EOM
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" --recipe-url=http://localhost:9000/recipes.tgz -o 'x::default' -z", :cwd => tmp_dir)
+      result.error!
+    end
+
+    it 'should fail when passed --recipe-url and not passed -z' do
+      result = shell_out("#{chef_client} --recipe-url=http://localhost:9000/recipes.tgz", :cwd => tmp_dir)
+      expect(result.exitstatus).to eq(1)
+    end
+  end
 end