chef 12.4.3 → 12.5.0.alpha.1

data/spec/integration/recipes/resource_action_spec.rb

@@ -0,0 +1,343 @@
+require 'support/shared/integration/integration_helper'
+
+describe "Resource.action" do
+  include IntegrationSupport
+
+  def converge(str=nil, file=nil, line=nil, &block)
+    if block
+      super(&block)
+    else
+      super() do
+        eval(str, nil, file, line)
+      end
+    end
+  end
+
+  shared_context "ActionJackson" do
+    it "The default action is the first declared action" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_recipe_dsl
+      expect(ActionJackson.succeeded).to eq true
+    end
+
+    it "The action can access recipe DSL" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_recipe_dsl
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_recipe_dsl
+      expect(ActionJackson.succeeded).to eq true
+    end
+
+    it "The action can access attributes" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_attribute
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_attribute
+      expect(ActionJackson.succeeded).to eq 'foo!'
+    end
+
+    it "The action can access public methods" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_method
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_method
+      expect(ActionJackson.succeeded).to eq 'foo_public!'
+    end
+
+    it "The action can access protected methods" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_protected_method
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_protected_method
+      expect(ActionJackson.succeeded).to eq 'foo_protected!'
+    end
+
+    it "The action cannot access private methods" do
+      expect {
+        converge(<<-EOM, __FILE__, __LINE__+1)
+          #{resource_dsl} 'hi' do
+            foo 'foo!'
+            action :access_private_method
+          end
+        EOM
+      }.to raise_error(NameError)
+      expect(ActionJackson.ran_action).to eq :access_private_method
+    end
+
+    it "The action cannot access resource instance variables" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_instance_variable
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_instance_variable
+      expect(ActionJackson.succeeded).to be_nil
+    end
+
+    it "The action does not compile until the prior resource has converged" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        ruby_block 'wow' do
+          block do
+            ActionJackson.ruby_block_converged = 'ruby_block_converged!'
+          end
+        end
+
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_class_method
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_class_method
+      expect(ActionJackson.succeeded).to eq 'ruby_block_converged!'
+    end
+
+    it "The action's resources converge before the next resource converges" do
+      converge <<-EOM, __FILE__, __LINE__+1
+        #{resource_dsl} 'hi' do
+          foo 'foo!'
+          action :access_attribute
+        end
+
+        ruby_block 'wow' do
+          block do
+            ActionJackson.ruby_block_converged = ActionJackson.succeeded
+          end
+        end
+      EOM
+      expect(ActionJackson.ran_action).to eq :access_attribute
+      expect(ActionJackson.succeeded).to eq 'foo!'
+      expect(ActionJackson.ruby_block_converged).to eq 'foo!'
+    end
+  end
+
+  context "With resource 'action_jackson'" do
+    before(:context) {
+      class ActionJackson < Chef::Resource
+        use_automatic_resource_name
+        def foo(value=nil)
+          @foo = value if value
+          @foo
+        end
+        def blarghle(value=nil)
+          @blarghle = value if value
+          @blarghle
+        end
+
+        class <<self
+          attr_accessor :ran_action
+          attr_accessor :succeeded
+          attr_accessor :ruby_block_converged
+        end
+
+        public
+        def foo_public
+          'foo_public!'
+        end
+        protected
+        def foo_protected
+          'foo_protected!'
+        end
+        private
+        def foo_private
+          'foo_private!'
+        end
+
+        public
+        action :access_recipe_dsl do
+          ActionJackson.ran_action = :access_recipe_dsl
+          ruby_block 'hi there' do
+            block do
+              ActionJackson.succeeded = true
+            end
+          end
+        end
+        action :access_attribute do
+          ActionJackson.ran_action = :access_attribute
+          ActionJackson.succeeded = foo
+          ActionJackson.succeeded += " #{blarghle}" if blarghle
+          ActionJackson.succeeded += " #{bar}" if respond_to?(:bar)
+        end
+        action :access_attribute2 do
+          ActionJackson.ran_action = :access_attribute2
+          ActionJackson.succeeded = foo
+          ActionJackson.succeeded += " #{blarghle}" if blarghle
+          ActionJackson.succeeded += " #{bar}" if respond_to?(:bar)
+        end
+        action :access_method do
+          ActionJackson.ran_action = :access_method
+          ActionJackson.succeeded = foo_public
+        end
+        action :access_protected_method do
+          ActionJackson.ran_action = :access_protected_method
+          ActionJackson.succeeded = foo_protected
+        end
+        action :access_private_method do
+          ActionJackson.ran_action = :access_private_method
+          ActionJackson.succeeded = foo_private
+        end
+        action :access_instance_variable do
+          ActionJackson.ran_action = :access_instance_variable
+          ActionJackson.succeeded = @foo
+        end
+        action :access_class_method do
+          ActionJackson.ran_action = :access_class_method
+          ActionJackson.succeeded = ActionJackson.ruby_block_converged
+        end
+      end
+    }
+    before(:each) {
+      ActionJackson.ran_action = :error
+      ActionJackson.succeeded = :error
+      ActionJackson.ruby_block_converged = :error
+    }
+
+    it_behaves_like "ActionJackson" do
+      let(:resource_dsl) { :action_jackson }
+    end
+
+    context "And 'action_jackgrandson' inheriting from ActionJackson and changing nothing" do
+      before(:context) {
+        class ActionJackgrandson < ActionJackson
+          use_automatic_resource_name
+        end
+      }
+
+      it_behaves_like "ActionJackson" do
+        let(:resource_dsl) { :action_jackgrandson }
+      end
+    end
+
+    context "And 'action_jackalope' inheriting from ActionJackson with an extra attribute and action" do
+      before(:context) {
+        class ActionJackalope < ActionJackson
+          use_automatic_resource_name
+
+          def foo(value=nil)
+            @foo = "#{value}alope" if value
+            @foo
+          end
+          def bar(value=nil)
+            @bar = "#{value}alope" if value
+            @bar
+          end
+          class <<self
+            attr_accessor :jackalope_ran
+          end
+          action :access_jackalope do
+            ActionJackalope.jackalope_ran = :access_jackalope
+            ActionJackalope.succeeded = "#{foo} #{blarghle} #{bar}"
+          end
+          action :access_attribute do
+            super()
+            ActionJackalope.jackalope_ran = :access_attribute
+            ActionJackalope.succeeded = ActionJackson.succeeded
+          end
+        end
+      }
+      before do
+        ActionJackalope.jackalope_ran = nil
+      end
+
+      context "action_jackson still behaves the same" do
+        it_behaves_like "ActionJackson" do
+          let(:resource_dsl) { :action_jackson }
+        end
+      end
+
+      it "The default action remains the same even though new actions were specified first" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+          end
+        }
+        expect(ActionJackson.ran_action).to eq :access_recipe_dsl
+        expect(ActionJackson.succeeded).to eq true
+      end
+
+      it "new actions run, and can access overridden, new, and overridden attributes" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+            blarghle 'blarghle!'
+            action :access_jackalope
+          end
+        }
+        expect(ActionJackalope.jackalope_ran).to eq :access_jackalope
+        expect(ActionJackalope.succeeded).to eq "foo!alope blarghle! bar!alope"
+      end
+
+      it "overridden actions run, call super, and can access overridden, new, and overridden attributes" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+            blarghle 'blarghle!'
+            action :access_attribute
+          end
+        }
+        expect(ActionJackson.ran_action).to eq :access_attribute
+        expect(ActionJackson.succeeded).to eq "foo!alope blarghle! bar!alope"
+        expect(ActionJackalope.jackalope_ran).to eq :access_attribute
+        expect(ActionJackalope.succeeded).to eq "foo!alope blarghle! bar!alope"
+      end
+
+      it "non-overridden actions run and can access overridden and non-overridden variables (but not necessarily new ones)" do
+        converge {
+          action_jackalope 'hi' do
+            foo 'foo!'
+            bar 'bar!'
+            blarghle 'blarghle!'
+            action :access_attribute2
+          end
+        }
+        expect(ActionJackson.ran_action).to eq :access_attribute2
+        expect(ActionJackson.succeeded).to eq("foo!alope blarghle! bar!alope").or(eq("foo!alope blarghle!"))
+      end
+    end
+  end
+
+  context "With a resource with no actions" do
+    before(:context) {
+      class NoActionJackson < Chef::Resource
+        use_automatic_resource_name
+
+        def foo(value=nil)
+          @foo = value if value
+          @foo
+        end
+
+        class <<self
+          attr_accessor :action_was
+        end
+      end
+    }
+    it "The default action is :nothing" do
+      converge {
+        no_action_jackson 'hi' do
+          foo 'foo!'
+          NoActionJackson.action_was = action
+        end
+      }
+      expect(NoActionJackson.action_was).to eq [:nothing]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -118,6 +118,7 @@ RSpec.configure do |config|
   config.filter_run_excluding :volatile_from_verify => false
 
   config.filter_run_excluding :skip_appveyor => true if ENV["APPVEYOR"]
+  config.filter_run_excluding :appveyor_only => true unless ENV["APPVEYOR"]
 
   config.filter_run_excluding :windows_only => true unless windows?
   config.filter_run_excluding :not_supported_on_mac_osx_106 => true if mac_osx_106?

data/spec/support/shared/functional/win32_service.rb

@@ -46,7 +46,8 @@ shared_context "using Win32::Service" do
       :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__), '../../platforms/win32/spec_service.rb'))
+      :service_file_path => File.expand_path(File.join(File.dirname(__FILE__), '../../platforms/win32/spec_service.rb')),
+      :delayed_start => true
     }
   }
 

data/spec/unit/application/solo_spec.rb

@@ -106,7 +106,8 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
     describe "when the recipe_url configuration option is specified" do
       let(:tarfile) { StringIO.new("remote_tarball_content") }
       let(:target_file) { StringIO.new }
-
+      let(:shellout) { double(run_command: nil, error!: nil, stdout: '') }
+     
       before do
         Chef::Config[:cookbook_path] = "#{Dir.tmpdir}/chef-solo/cookbooks"
         Chef::Config[:recipe_url] = "http://junglist.gen.nz/recipes.tgz"
@@ -117,7 +118,7 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
         allow(app).to receive(:open).with("http://junglist.gen.nz/recipes.tgz").and_yield(tarfile)
         allow(File).to receive(:open).with("#{Dir.tmpdir}/chef-solo/recipes.tgz", "wb").and_yield(target_file)
 
-        allow(Chef::Mixin::Command).to receive(:run_command).and_return(true)
+        allow(Mixlib::ShellOut).to receive(:new).and_return(shellout)
       end
 
       it "should create the recipes path based on the parent of the cookbook path" do
@@ -136,7 +137,7 @@ Enable chef-client interval runs by setting `:client_fork = true` in your config
       end
 
       it "should untar the target file to the parent of the cookbook path" do
-        expect(Chef::Mixin::Command).to receive(:run_command).with({:command => "tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo"}).and_return(true)
+        expect(Mixlib::ShellOut).to receive(:new).with("tar zxvf #{Dir.tmpdir}/chef-solo/recipes.tgz -C #{Dir.tmpdir}/chef-solo")  
         app.reconfigure
       end
     end

data/spec/unit/chef_class_spec.rb

@@ -88,4 +88,27 @@ describe "Chef class" do
       expect(Chef.node).to eql(node)
     end
   end
+
+  context '#event_handler' do
+    it 'adds a new handler' do
+      x = 1
+      Chef.event_handler do
+        on :converge_start do
+          x = 2
+        end
+      end
+      expect(Chef::Config[:event_handlers]).to_not be_empty
+      Chef::Config[:event_handlers].first.send(:converge_start)
+      expect(x).to eq(2)
+    end
+
+    it 'raise error if unknown event type is passed' do
+      expect do
+        Chef.event_handler do
+          on :yolo do
+          end
+        end
+      end.to raise_error(Chef::Exceptions::InvalidEventType)
+    end
+  end
 end

data/spec/unit/chef_fs/path_util_spec.rb

@@ -0,0 +1,108 @@
+#
+# Author:: Kartik Null Cating-Subramanian (<ksubramanian@chef.io>)
+# Copyright:: Copyright (c) 2015 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 'spec_helper'
+require 'chef/chef_fs/path_utils'
+
+describe Chef::ChefFS::PathUtils do
+  context 'invoking join' do
+    it 'joins well-behaved distinct path elements' do
+      expect(Chef::ChefFS::PathUtils.join('a', 'b', 'c')).to eq('a/b/c')
+    end
+
+    it 'strips extraneous slashes in the middle of paths' do
+      expect(Chef::ChefFS::PathUtils.join('a/', '/b', '/c/')).to eq('a/b/c')
+      expect(Chef::ChefFS::PathUtils.join('a/', '/b', '///c/')).to eq('a/b/c')
+    end
+
+    it 'preserves the whether the first element was absolute or not' do
+      expect(Chef::ChefFS::PathUtils.join('/a/', '/b', 'c/')).to eq('/a/b/c')
+      expect(Chef::ChefFS::PathUtils.join('///a/', '/b', 'c/')).to eq('/a/b/c')
+    end
+  end
+
+  context 'invoking is_absolute?' do
+    it 'confirms that paths starting with / are absolute' do
+      expect(Chef::ChefFS::PathUtils.is_absolute?('/foo/bar/baz')).to be true
+      expect(Chef::ChefFS::PathUtils.is_absolute?('/foo')).to be true
+    end
+
+    it 'confirms that paths starting with // are absolute even though that looks like some windows network path' do
+      expect(Chef::ChefFS::PathUtils.is_absolute?('//foo/bar/baz')).to be true
+    end
+
+    it 'confirms that root is indeed absolute' do
+      expect(Chef::ChefFS::PathUtils.is_absolute?('/')).to be true
+    end
+
+    it 'confirms that paths starting without / are relative' do
+      expect(Chef::ChefFS::PathUtils.is_absolute?('foo/bar/baz')).to be false
+      expect(Chef::ChefFS::PathUtils.is_absolute?('a')).to be false
+    end
+
+    it 'returns false for an empty path.' do
+      expect(Chef::ChefFS::PathUtils.is_absolute?('')).to be false
+    end
+  end
+
+  context 'invoking realest_path' do
+    let(:good_path) { File.dirname(__FILE__) }
+    let(:parent_path) { File.dirname(good_path) }
+
+    it 'handles paths with no wildcards or globs' do
+      expect(Chef::ChefFS::PathUtils.realest_path(good_path)).to eq(File.expand_path(good_path))
+    end
+
+    it 'handles paths with .. and .' do
+      expect(Chef::ChefFS::PathUtils.realest_path(good_path+'/../.')).to eq(File.expand_path(parent_path))
+    end
+
+    it 'handles paths with *' do
+      expect(Chef::ChefFS::PathUtils.realest_path(good_path + '/*/foo')).to eq(File.expand_path(good_path + '/*/foo'))
+    end
+
+    it 'handles directories that do not exist' do
+      expect(Chef::ChefFS::PathUtils.realest_path(good_path + '/something/or/other')).to eq(File.expand_path(good_path + '/something/or/other'))
+    end
+
+    it 'handles root correctly' do
+      if Chef::Platform.windows?
+        expect(Chef::ChefFS::PathUtils.realest_path('C:/')).to eq('C:/')
+      else
+        expect(Chef::ChefFS::PathUtils.realest_path('/')).to eq('/')
+      end
+    end
+  end
+
+  context 'invoking descendant_path' do
+    it 'handles paths with various casing on windows' do
+      allow(Chef::ChefFS).to receive(:windows?) { true }
+      expect(Chef::ChefFS::PathUtils.descendant_path('C:/ab/b/c', 'C:/AB/B')).to eq('c')
+      expect(Chef::ChefFS::PathUtils.descendant_path('C:/ab/b/c', 'c:/ab/B')).to eq('c')
+    end
+
+    it 'returns nil if the path does not have the given ancestor' do
+      expect(Chef::ChefFS::PathUtils.descendant_path('/D/E/F', '/A/B/C')).to be_nil
+      expect(Chef::ChefFS::PathUtils.descendant_path('/A/B/D', '/A/B/C')).to be_nil
+    end
+
+    it 'returns blank if the ancestor equals the path' do
+      expect(Chef::ChefFS::PathUtils.descendant_path('/A/B/D', '/A/B/D')).to eq('')
+    end
+  end
+end