chef 12.0.0.alpha.1 → 12.0.0.alpha.2

data/spec/functional/resource/deploy_revision_spec.rb

@@ -59,7 +59,6 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
   let(:event_dispatch) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, event_dispatch) }
 
-
   # These tests use git's bundle feature, which is a way to export an entire
   # git repo (or subset of commits) as a single file.
   #
@@ -799,7 +798,6 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
           deploy_to_latest_with_callback_tracking.run_action(:deploy)
         end
 
-
         let(:deploy_that_fails) do
           resource = deploy_to_latest_rev.dup
           errant_callback = lambda {|x| raise Exception, "I am a failed deploy" }
@@ -882,5 +880,3 @@ describe Chef::Resource::DeployRevision, :unix_only => true do
 
   end
 end
-
-

data/spec/functional/resource/file_spec.rb

@@ -24,12 +24,18 @@ describe Chef::Resource::File do
   let(:file_base) { "file_spec" }
   let(:expected_content) { "Don't fear the ruby." }
 
-  def create_resource
+  def create_resource(opts={})
     events = Chef::EventDispatch::Dispatcher.new
     node = Chef::Node.new
     run_context = Chef::RunContext.new(node, {}, events)
-    resource = Chef::Resource::File.new(path, run_context)
-    resource
+
+    use_path = if opts[:use_relative_path]
+      File.basename(path)
+    else
+      path
+    end
+
+    Chef::Resource::File.new(use_path, run_context)
   end
 
   let(:resource) do
@@ -42,6 +48,10 @@ describe Chef::Resource::File do
     create_resource
   end
 
+  let(:resource_with_relative_path) do
+    create_resource(:use_relative_path => true)
+  end
+
   let(:unmanaged_content) do
     "This is file content that is not managed by chef"
   end
@@ -74,6 +84,19 @@ describe Chef::Resource::File do
     end
   end
 
+  # github issue 1842.
+  describe "when running action :create on a relative path" do
+    before do
+      resource_with_relative_path.run_action(:create)
+    end
+
+    context "and the file exists" do
+      it "should run without an exception" do
+        resource_with_relative_path.run_action(:create)
+      end
+    end
+  end
+
   describe "when running action :touch" do
     context "and the target file does not exist" do
       before do

data/spec/functional/resource/group_spec.rb

@@ -40,6 +40,11 @@ describe Chef::Resource::Group, :requires_root_or_running_windows, :not_supporte
     when "windows"
       user_sid = sid_string_from_user(user)
       user_sid.nil? ? false : Chef::Util::Windows::NetGroup.new(group_name).local_get_members.include?(user_sid)
+    when "mac_os_x"
+      membership_info = shell_out("dscl . -read /Groups/#{group_name}").stdout
+      members = membership_info.split(" ")
+      members.shift # Get rid of GroupMembership: string
+      members.include?(user)
     else
       Etc::getgrnam(group_name).mem.include?(user)
     end
@@ -420,6 +425,3 @@ downthestreetalwayshadagoodsmileonhisfacetheoldmanwalkingdownthestreeQQQQQQ" }
     end
   end
 end
-
-
-

data/spec/functional/resource/link_spec.rb

@@ -72,8 +72,8 @@ describe Chef::Resource::Link do
     end
   end
 
-  def canonicalize(path)
-    windows? ? path.gsub('/', '\\') : path
+  def paths_eql?(path1, path2)
+    Chef::Util::PathHelper.paths_eql?(path1, path2)
   end
 
   def symlink(a, b)
@@ -180,7 +180,7 @@ describe Chef::Resource::Link do
 
         it 'links to the target file' do
           symlink?(target_file).should be_true
-          readlink(target_file).should == canonicalize(to)
+          paths_eql?(readlink(target_file), to).should be_true
         end
         it 'marks the resource updated' do
           resource.should be_updated
@@ -201,7 +201,7 @@ describe Chef::Resource::Link do
 
         it 'leaves the file linked' do
           symlink?(target_file).should be_true
-          readlink(target_file).should == canonicalize(to)
+          paths_eql?(readlink(target_file), to).should be_true
         end
         it 'does not mark the resource updated' do
           resource.should_not be_updated
@@ -279,7 +279,7 @@ describe Chef::Resource::Link do
             before(:each) do
               symlink(to, target_file)
               symlink?(target_file).should be_true
-              readlink(target_file).should == canonicalize(to)
+              paths_eql?(readlink(target_file), to).should be_true
             end
             include_context 'create symbolic link is noop'
             include_context 'delete succeeds'
@@ -294,7 +294,7 @@ describe Chef::Resource::Link do
               File.open(@other_target, 'w') { |file| file.write('eek') }
               symlink(@other_target, target_file)
               symlink?(target_file).should be_true
-              readlink(target_file).should == canonicalize(@other_target)
+              paths_eql?(readlink(target_file), @other_target).should be_true
             end
             after(:each) do
               File.delete(@other_target)
@@ -311,7 +311,7 @@ describe Chef::Resource::Link do
               nonexistent = File.join(test_file_dir, make_tmpname('nonexistent_spec'))
               symlink(nonexistent, target_file)
               symlink?(target_file).should be_true
-              readlink(target_file).should == canonicalize(nonexistent)
+              paths_eql?(readlink(target_file), nonexistent).should be_true
             end
             include_context 'create symbolic link succeeds'
             include_context 'delete succeeds'
@@ -393,7 +393,7 @@ describe Chef::Resource::Link do
             File.open(@other_target, "w") { |file| file.write("eek") }
             symlink(@other_target, to)
             symlink?(to).should be_true
-            readlink(to).should == canonicalize(@other_target)
+            paths_eql?(readlink(to), @other_target).should be_true
           end
           after(:each) do
             File.delete(@other_target)
@@ -408,7 +408,7 @@ describe Chef::Resource::Link do
             @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
             symlink(@other_target, to)
             symlink?(to).should be_true
-            readlink(to).should == canonicalize(@other_target)
+            paths_eql?(readlink(to), @other_target).should be_true
           end
           context 'and the link does not yet exist' do
             include_context 'create symbolic link succeeds'
@@ -441,7 +441,7 @@ describe Chef::Resource::Link do
             before(:each) do
               symlink(to, target_file)
               symlink?(target_file).should be_true
-              readlink(target_file).should == canonicalize(to)
+              paths_eql?(readlink(target_file), to).should be_true
             end
             include_context 'create symbolic link is noop'
             include_context 'delete succeeds'
@@ -450,7 +450,7 @@ describe Chef::Resource::Link do
             before(:each) do
               symlink(absolute_to, target_file)
               symlink?(target_file).should be_true
-              readlink(target_file).should == canonicalize(absolute_to)
+              paths_eql?(readlink(target_file), absolute_to).should be_true
             end
             include_context 'create symbolic link succeeds'
             include_context 'delete succeeds'
@@ -478,7 +478,7 @@ describe Chef::Resource::Link do
           before(:each) do
             symlink(to, target_file)
             symlink?(target_file).should be_true
-            readlink(target_file).should == canonicalize(to)
+            paths_eql?(readlink(target_file), to).should be_true
           end
           include_context 'create hard link succeeds'
           it_behaves_like 'delete errors out'
@@ -552,7 +552,7 @@ describe Chef::Resource::Link do
             File.open(@other_target, "w") { |file| file.write("eek") }
             symlink(@other_target, to)
             symlink?(to).should be_true
-            readlink(to).should == canonicalize(@other_target)
+            paths_eql?(readlink(to), @other_target).should be_true
           end
           after(:each) do
             File.delete(@other_target)
@@ -564,7 +564,7 @@ describe Chef::Resource::Link do
               # OS X gets angry about this sort of link.  Bug in OS X, IMO.
               pending('OS X/FreeBSD/AIX symlink? and readlink working on hard links to symlinks', :if => (os_x? or freebsd? or aix?)) do
                 symlink?(target_file).should be_true
-                readlink(target_file).should == canonicalize(@other_target)
+                paths_eql?(readlink(target_file), @other_target).should be_true
               end
             end
             include_context 'delete is noop'
@@ -575,7 +575,7 @@ describe Chef::Resource::Link do
             @other_target = File.join(test_file_dir, make_tmpname("other_spec"))
             symlink(@other_target, to)
             symlink?(to).should be_true
-            readlink(to).should == canonicalize(@other_target)
+            paths_eql?(readlink(to), @other_target).should be_true
           end
           context 'and the link does not yet exist' do
             it 'links to the target file' do
@@ -588,7 +588,7 @@ describe Chef::Resource::Link do
                   File.exists?(target_file).should be_false
                 end
                 symlink?(target_file).should be_true
-                readlink(target_file).should == canonicalize(@other_target)
+                paths_eql?(readlink(target_file), @other_target).should be_true
               end
             end
             include_context 'delete is noop'

data/spec/functional/resource/reboot_spec.rb

@@ -0,0 +1,103 @@
+#
+# Author:: Chris Doherty <cdoherty@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef, 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::Reboot do
+
+  let(:expected) do
+    {
+      :delay_mins => 5,
+      :requested_by => "reboot resource functional test",
+      :reason => "reboot resource spec test"
+    }
+  end
+
+  def create_resource
+    node = Chef::Node.new
+    events = Chef::EventDispatch::Dispatcher.new
+    run_context = Chef::RunContext.new(node, {}, events)
+    resource = Chef::Resource::Reboot.new(expected[:requested_by], run_context)
+    resource.delay_mins(expected[:delay_mins])
+    resource.reason(expected[:reason])
+    resource
+  end
+
+  let(:resource) do
+    create_resource
+  end
+
+  shared_context 'testing run context modification' do
+    def test_reboot_action(resource)
+      reboot_info = resource.run_context.reboot_info
+      expect(reboot_info.keys.sort).to eq([:delay_mins, :reason, :requested_by, :timestamp])
+      expect(reboot_info[:delay_mins]).to eq(expected[:delay_mins])
+      expect(reboot_info[:reason]).to eq(expected[:reason])
+      expect(reboot_info[:requested_by]).to eq(expected[:requested_by])
+
+      expect(resource.run_context.reboot_requested?).to be_true
+    end
+  end
+
+  # the currently defined behavior for multiple calls to this resource is "last one wins."
+  describe 'the request_reboot_on_successful_run action' do
+    include_context 'testing run context modification'
+
+    before do
+      resource.run_action(:request_reboot)
+    end
+
+    after do
+      resource.run_context.cancel_reboot
+    end
+
+    it 'should have modified the run context correctly' do
+      test_reboot_action(resource)
+    end
+  end
+
+  describe 'the reboot_interrupt_run action' do
+    include_context 'testing run context modification'
+
+    after do
+      resource.run_context.cancel_reboot
+    end
+
+    it 'should have modified the run context correctly' do
+      # this doesn't actually test the flow of Chef::Client#do_run, unfortunately.
+      expect {
+        resource.run_action(:reboot_now)
+      }.to throw_symbol(:end_client_run_early)
+
+      test_reboot_action(resource)
+    end
+  end
+
+  describe "the cancel action" do
+    before do
+      resource.run_context.request_reboot(expected)
+      resource.run_action(:cancel)
+    end
+
+    it 'should have cleared the reboot request' do
+      # arguably we shouldn't be querying RunContext's internal data directly.
+      expect(resource.run_context.reboot_info).to eq({})
+      expect(resource.run_context.reboot_requested?).to be_false
+    end
+  end
+end

data/spec/integration/client/client_spec.rb

@@ -33,17 +33,17 @@ EOM
 
     context 'and no config file' do
       it 'should complete with success when cwd is just above cookbooks and paths are not specified' do
-        result = shell_out("#{chef_client} -z -o 'x::default' --config-file-jail \"#{path_to('')}\"", :cwd => path_to(''))
+        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", :cwd => path_to(''))
         result.error!
       end
 
       it 'should complete with success when cwd is below cookbooks and paths are not specified' do
-        result = shell_out("#{chef_client} -z -o 'x::default' --config-file-jail \"#{path_to('')}\"", :cwd => path_to('cookbooks/x'))
+        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", :cwd => path_to('cookbooks/x'))
         result.error!
       end
 
       it 'should fail when cwd is below high above and paths are not specified' do
-        result = shell_out("#{chef_client} -z -o 'x::default' --config-file-jail \"#{path_to('')}\"", :cwd => File.expand_path('..', path_to('')))
+        result = shell_out("#{chef_client} -z -o 'x::default' --disable-config", :cwd => File.expand_path('..', path_to('')))
         result.exitstatus.should == 1
       end
     end
@@ -52,15 +52,11 @@ EOM
       before { file '.chef/knife.rb', 'xxx.xxx' }
 
       it 'should load .chef/knife.rb when -z is specified' do
-        result = shell_out("#{chef_client} -z -o 'x::default' --config-file-jail \"#{path_to('')}\"", :cwd => path_to(''))
+        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")
       end
 
-      it 'fails to load .chef/knife.rb when -z is specified and --config-file-jail does not include the .chef/knife.rb' do
-        result = shell_out("#{chef_client} -z -o 'x::default' --config-file-jail \"#{path_to('roles')}\"", :cwd => path_to(''))
-        result.error!
-      end
     end
 
     it "should complete with success" do

data/spec/integration/client/ipv6_spec.rb

@@ -76,7 +76,7 @@ END_CLIENT_RB
 
   let(:chef_dir) { File.join(File.dirname(__FILE__), "..", "..", "..", "bin") }
 
-  let(:chef_client_cmd) { %Q[chef-client -c "#{path_to('config/client.rb')}" -lwarn] }
+  let(:chef_client_cmd) { %Q[ruby #{chef_dir}/chef-client -c "#{path_to('config/client.rb')}" -lwarn] }
 
   after do
     FileUtils.rm_rf(cache_path)

data/spec/integration/knife/cookbook_api_ipv6_spec.rb

@@ -62,6 +62,7 @@ END_VALIDATION_PEM
     end
 
     let(:chef_dir) { File.join(File.dirname(__FILE__), "..", "..", "..", "bin") }
+    let(:knife) { "ruby #{chef_dir}/knife" }
 
     let(:knife_config_flag) { "-c '#{path_to("config/knife.rb")}'" }
 
@@ -88,7 +89,7 @@ END_CLIENT_RB
         end
 
         it "successfully uploads a cookbook" do
-          shell_out!("knife cookbook upload apache2 #{knife_config_flag}", :cwd => chef_dir)
+          shell_out!("#{knife} cookbook upload apache2 #{knife_config_flag}", :cwd => chef_dir)
           versions_list_json = Chef::HTTP::Simple.new("http://[::1]:8900").get("/cookbooks/apache2", "accept" => "application/json")
           versions_list = Chef::JSONCompat.from_json(versions_list_json)
           versions_list["apache2"]["versions"].should_not be_empty
@@ -96,7 +97,7 @@ END_CLIENT_RB
 
         context "and the cookbook has been uploaded to the server" do
           before do
-            shell_out!("knife cookbook upload apache2 #{knife_config_flag}", :cwd => chef_dir)
+            shell_out!("#{knife} cookbook upload apache2 #{knife_config_flag}", :cwd => chef_dir)
           end
 
           it "downloads the cookbook" do

data/spec/integration/knife/delete_spec.rb

@@ -961,4 +961,43 @@ EOM
       end
     end
   end
+
+  when_the_chef_server "is in Enterprise mode", :osc_compat => false, :single_org => false do
+    before do
+      organization 'foo' do
+        container 'x', {}
+        group 'x', {}
+      end
+    end
+
+    before :each do
+      Chef::Config.chef_server_url = URI.join(Chef::Config.chef_server_url, '/organizations/foo')
+    end
+
+    it 'knife delete /acls/containers/environments.json fails with a reasonable error' do
+      knife('delete /acls/containers/environments.json').should_fail "ERROR: /acls/containers/environments.json (remote) cannot be deleted.\n"
+    end
+
+    it 'knife delete /containers/x.json succeeds' do
+      knife('delete /containers/x.json').should_succeed "Deleted /containers/x.json\n"
+      knife('raw /containers/x.json').should_fail(/404/)
+    end
+
+    it 'knife delete /groups/x.json succeeds' do
+      knife('delete /groups/x.json').should_succeed "Deleted /groups/x.json\n"
+      knife('raw /groups/x.json').should_fail(/404/)
+    end
+
+    it 'knife delete /org.json fails with a reasonable error' do
+      knife('delete /org.json').should_fail "ERROR: /org.json (remote) cannot be deleted.\n"
+    end
+
+    it 'knife delete /invitations.json fails with a reasonable error' do
+      knife('delete /invitations.json').should_fail "ERROR: /invitations.json (remote) cannot be deleted.\n"
+    end
+
+    it 'knife delete /members.json fails with a reasonable error' do
+      knife('delete /members.json').should_fail "ERROR: /members.json (remote) cannot be deleted.\n"
+    end
+  end
 end