halite 1.8.1 → 1.8.2

data/gemfiles/chef-14.0.gemfile

@@ -0,0 +1,19 @@
+#
+# Copyright 2018, Noah Kantrowitz
+#
+# 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.
+#
+
+eval_gemfile File.expand_path('../../Gemfile', __FILE__)
+
+gem 'chef', '~> 14.0.202'

data/gemfiles/chef-14.1.gemfile

@@ -0,0 +1,19 @@
+#
+# Copyright 2018, Noah Kantrowitz
+#
+# 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.
+#
+
+eval_gemfile File.expand_path('../../Gemfile', __FILE__)
+
+gem 'chef', '~> 14.1.12'

data/gemfiles/chef-14.2.gemfile

@@ -0,0 +1,19 @@
+#
+# Copyright 2018, Noah Kantrowitz
+#
+# 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.
+#
+
+eval_gemfile File.expand_path('../../Gemfile', __FILE__)
+
+gem 'chef', '~> 14.2.0'

data/gemfiles/chef-14.3.gemfile

@@ -0,0 +1,19 @@
+#
+# Copyright 2018, Noah Kantrowitz
+#
+# 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.
+#
+
+eval_gemfile File.expand_path('../../Gemfile', __FILE__)
+
+gem 'chef', '~> 14.3.37'

data/gemfiles/chef-14.4.gemfile

@@ -0,0 +1,19 @@
+#
+# Copyright 2018, Noah Kantrowitz
+#
+# 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.
+#
+
+eval_gemfile File.expand_path('../../Gemfile', __FILE__)
+
+gem 'chef', '~> 14.4.56'

data/gemfiles/{chef-12.4.0.gemfile → chef-14.gemfile}

@@ -1,5 +1,5 @@
 #
-# Copyright 2015, Noah Kantrowitz
+# Copyright 2018, Noah Kantrowitz
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,4 +16,4 @@
 
 eval_gemfile File.expand_path('../../Gemfile', __FILE__)
 
-gem 'chef', '12.4.0'
+gem 'chef', '~> 14.4'

data/lib/halite/spec_helper.rb

@@ -55,6 +55,8 @@ module Halite
     autoload :Patcher, 'halite/spec_helper/patcher'
     autoload :Runner, 'halite/spec_helper/runner'
     extend RSpec::SharedContext
+    def self.described_class; nil; end
+    include ChefSpec::API
 
     # @!attribute [r] step_into
     #   Resource names to step in to when running this example.
@@ -91,29 +93,36 @@ module Halite
     #   @example Enable Fauxhai attributes
     #     let(:chefspec_options) { {platform: 'ubuntu', version: '12.04'} }
     let(:chefspec_options) { Hash.new }
-    # @!attribute [r] chef_runner
-    #   ChefSpec runner for this example.
-    #   @return [ChefSpec::SoloRunner]
-    let(:chef_runner) do
-      Halite::SpecHelper::Runner.new(
-        {
-          step_into: step_into,
-          default_attributes: default_attributes,
-          normal_attributes: normal_attributes,
-          override_attributes: override_attributes,
-          halite_gemspec: halite_gemspec,
-          # Default platform and version.
-          platform: 'ubuntu',
-          version: '16.04',
-        }.merge(chefspec_options)
-      )
+
+    # Cross-link the Halite and ChefSpec data.
+    let(:chefspec_platform) do
+      chefspec_options[:platform] || 'ubuntu'
+    end
+    let(:chefspec_platform_version) do
+      chefspec_options[:version]
+    end
+
+    # Merge in extra options data.
+    def chef_runner_options
+      super.tap do |options|
+        options[:halite_gemspec] = halite_gemspec
+        # And some legacy data.
+        options[:default_attributes].update(default_attributes)
+        options[:normal_attributes].update(normal_attributes)
+        options[:override_attributes].update(override_attributes)
+        options.update(chefspec_options)
+      end
+    end
+
+    # Custom runner class.
+    def chef_runner_class
+      Halite::SpecHelper::Runner
+    end
+
+    # Don't try to converge any recipes, even by default.
+    let(:chef_run) do
+      chef_runner.converge
     end
-    # @!attribute [r] chef_run
-    #   Trigger a Chef converge. By default no resources are converged. This is
-    #   normally overwritten by the {#recipe} helper.
-    #   @return [ChefSpec::SoloRunner]
-    #   @see #recipe
-    let(:chef_run) { chef_runner.converge() }
 
     # An alias for slightly more semantic meaning, just forces the lazy #subject
     # to run.
@@ -172,7 +181,7 @@ module Halite
       #   end
       def recipe(*recipe_names, subject: true, &block)
         # Keep the actual logic in a let in case I want to define the subject as something else
-        let(:chef_run) { chef_runner.converge(*recipe_names, &block) }
+        let(:chef_run) { recipe_names.empty? ? chef_runner.converge_block(&block) : chef_runner.converge(*recipe_names) }
         subject { chef_run } if subject
       end
 
@@ -192,7 +201,8 @@ module Halite
       #     end
       #     it { is_expected.to run_ruby_block('test') }
       #   end
-      def step_into(name, resource_name=nil, unwrap_notifying_block: true)
+      def step_into(name=nil, resource_name=nil, unwrap_notifying_block: true)
+        return super() if name.nil?
         resource_class = if name.is_a?(Class)
           name
         elsif resources[name.to_sym]
@@ -210,16 +220,6 @@ module Halite
           Chef::Mixin::ConvertToClassName.convert_to_snake_case(resource_class.name.split('::').last)
         end
 
-        # Add a resource-level matcher to ChefSpec.
-        ChefSpec.define_matcher(resource_name)
-
-        # Figure out the available actions and create ChefSpec matchers.
-        resource_class.new(nil, nil).allowed_actions.each do |action|
-          define_method("#{action}_#{resource_name}") do |instance_name|
-            ChefSpec::Matchers::ResourceMatcher.new(resource_name, action, instance_name)
-          end
-        end
-
         # Patch notifying_block from Poise::Provider to just run directly.
         # This is not a great solution but it is better than nothing for right
         # now. In the future this should maybe do an internal converge but using
@@ -238,7 +238,7 @@ module Halite
         end
 
         # Add to the let variable passed in to ChefSpec.
-        before { step_into << resource_name }
+        super(resource_name)
       end
 
       # Define a resource class for use in an example group. By default the
@@ -333,7 +333,7 @@ module Halite
         around do |ex|
           if patch && resource(name) == resource_class
             # We haven't been overridden from a nested scope.
-            Patcher.patch(name, resource_class, Chef::Resource) { ex.run }
+            Patcher.patch(name, resource_class) { ex.run }
           else
             ex.run
           end
@@ -424,7 +424,7 @@ module Halite
         around do |ex|
           if patch && provider(name) == provider_class
             # We haven't been overridden from a nested scope.
-            Patcher.patch(name, provider_class, Chef::Provider) { ex.run }
+            Patcher.patch(name, provider_class) { ex.run }
           else
             ex.run
           end

data/lib/halite/spec_helper/patcher.rb

@@ -26,30 +26,16 @@ module Halite
     # @since 1.0.0
     # @api private
     module Patcher
-      # Flag to disable module-name patching.
-      DISABLE_PATCH_MODULE = ::Gem::Requirement.create('>= 13').satisfied_by?(::Gem::Version.create(Chef::VERSION))
-
       # Patch a class in to Chef for the duration of a block.
       #
       # @param name [String, Symbol] Name to create in snake-case (eg. :my_name).
       # @param klass [Class] Class to patch in.
-      # @param mod [Module] Optional module to create a constant in.
       # @param block [Proc] Block to execute while the patch is available.
       # @return [void]
-      def self.patch(name, klass, mod=nil, &block)
-        patch_descendants_tracker(klass) do
-          patch_node_map(name, klass) do
-            patch_priority_map(name, klass) do
-              patch_handler_map(name, klass) do
-                patch_recipe_dsl(name, klass) do
-                  if mod
-                    patch_module(mod, name, klass, &block)
-                  else
-                    block.call
-                  end
-                end
-              end
-            end
+      def self.patch(name, klass, &block)
+        patch_handler_map(name, klass) do
+          patch_recipe_dsl(name, klass) do
+            block.call
           end
         end
       end
@@ -65,10 +51,8 @@ module Halite
       def self.post_create_cleanup(name, klass)
         # Remove from DSL.
         Chef::DSL::Resources.remove_resource_dsl(name) if defined?(Chef::DSL::Resources.remove_resource_dsl)
-        # Remove from DescendantsTracker.
-        Chef::Mixin::DescendantsTracker.direct_descendants(klass.superclass).delete(klass)
-        # Remove from the priority and handler maps.
-        {priority: priority_map_for(klass), handler: handler_map_for(klass)}.each do |type, map|
+        # Remove from the handler map.
+        {handler: handler_map_for(klass)}.each do |type, map|
           if map
             # Make sure we add name in there too because anonymous classes don't
             # get a handler map registration by default.
@@ -78,78 +62,6 @@ module Halite
             klass.instance_variable_set(:"@halite_original_#{type}_keys", removed_keys)
           end
         end
-        # Remove from the global node map.
-        if defined?(Chef::Resource.node_map)
-          removed_keys = remove_from_node_map(Chef::Resource.node_map, klass)
-          # Used down in patch_node_map.
-          klass.instance_variable_set(:@halite_original_nodemap_keys, removed_keys)
-        end
-      end
-
-      # Patch an object in to a global namespace for the duration of a block.
-      #
-      # @param mod [Module] Namespace to patch in to.
-      # @param name [String, Symbol] Name to create in snake-case (eg. :my_name).
-      # @param obj Object to patch in.
-      # @param block [Proc] Block to execute while the name is available.
-      # @return [void]
-      def self.patch_module(mod, name, obj, &block)
-        return block.call if DISABLE_PATCH_MODULE
-        class_name = Chef::Mixin::ConvertToClassName.convert_to_class_name(name.to_s)
-        if mod.const_defined?(class_name, false)
-          old_class = mod.const_get(class_name, false)
-          # We are only allowed to patch over things installed by patch_module
-          raise "#{mod.name}::#{class_name} is already defined" if !old_class.instance_variable_get(:@poise_patch_module)
-          # Remove it before setting to avoid the redefinition warning
-          mod.send(:remove_const, class_name)
-        end
-        # Tag our objects so we know we are allowed to overwrite those, but not other stuff.
-        obj.instance_variable_set(:@poise_patch_module, true)
-        mod.const_set(class_name, obj)
-        begin
-          block.call
-        ensure
-          # Same as above, have to remove before set because warnings
-          mod.send(:remove_const, class_name)
-          mod.const_set(class_name, old_class) if old_class
-        end
-      end
-
-      # Patch an object in to Chef's DescendantsTracker system for the duration
-      # of a code block.
-      #
-      # @param klass [Class] Class to patch in.
-      # @param block [Proc] Block to execute while the patch is available.
-      # @return [void]
-      def self.patch_descendants_tracker(klass, &block)
-        begin
-          # Re-add to tracking.
-          Chef::Mixin::DescendantsTracker.store_inherited(klass.superclass, klass)
-          block.call
-        ensure
-          # Clean up after ourselves.
-          Chef::Mixin::DescendantsTracker.direct_descendants(klass.superclass).delete(klass)
-        end
-      end
-
-      # Patch a class in to its node_map. This is not used in 12.4+.
-      #
-      # @param name [Symbol] Name to patch in.
-      # @param klass [Class] Resource class to patch in.
-      # @param block [Proc] Block to execute while the patch is available.
-      # @return [void]
-      def self.patch_node_map(name, klass, &block)
-        return block.call unless defined?(klass.node_map)
-        begin
-          # Technically this is set to true on >=12.4, but this should work.
-          keys = klass.instance_variable_get(:@halite_original_nodemap_keys) | [name.to_sym]
-          keys.each do |key|
-            klass.node_map.set(key, klass)
-          end
-          block.call
-        ensure
-          remove_from_node_map(klass.node_map, klass)
-        end
       end
 
       # Patch a resource in to Chef's recipe DSL for the duration of a code
@@ -169,28 +81,6 @@ module Halite
         end
       end
 
-      # Patch a class in to the correct priority map for the duration of a code
-      # block. This is a no-op before Chef 12.4.
-      #
-      # @since 1.0.4
-      # @param name [Symbol] Name to patch in.
-      # @param klass [Class] Resource or provider class to patch in.
-      # @param block [Proc] Block to execute while the patch is available.
-      # @return [void]
-      def self.patch_priority_map(name, klass, &block)
-        priority_map = priority_map_for(klass)
-        return block.call unless priority_map
-        begin
-          # Unlike patch_node_map, this has to be an array!
-          klass.instance_variable_get(:@halite_original_priority_keys).each do |key|
-            priority_map.set(key, [klass])
-          end
-          block.call
-        ensure
-          remove_from_node_map(priority_map, klass)
-        end
-      end
-
       # Patch a class in to the correct handler map for the duration of a code
       # block. This is a no-op before Chef 12.4.1.
       #
@@ -214,19 +104,6 @@ module Halite
 
       private
 
-      # Find the global priority map for a class.
-      #
-      # @since 1.0.4
-      # @param klass [Class] Resource or provider class to look up.
-      # @return [nil, Chef::Platform::ResourcePriorityMap, Chef::Platform::ProviderPriorityMap]
-      def self.priority_map_for(klass)
-        if defined?(Chef.resource_priority_map) && klass < Chef::Resource
-          Chef.resource_priority_map
-        elsif defined?(Chef.provider_priority_map) && klass < Chef::Provider
-          Chef.provider_priority_map
-        end
-      end
-
       # Find the global handler map for a class.
       #
       # @since 1.0.7

data/lib/halite/spec_helper/runner.rb

@@ -30,45 +30,19 @@ module Halite
     #
     # @since 1.0.0
     class Runner < ChefSpec::SoloRunner
-      def self.converge(*recipe_names, &block)
-        options = if recipe_names.last.is_a?(Hash)
-          # Was called with options
-          recipe_names.pop
-        else
-          {}
-        end
-        new(options).tap do |instance|
-          instance.converge(*recipe_names, &block)
-        end
+      def initialize(options={})
+        # Store the gemspec for later use
+        @halite_gemspec = options[:halite_gemspec]
+        super
       end
 
-      def initialize(options={})
-        # Repeating the detault platform.
-        options[:platform] ||= 'ubuntu'
-        options[:version] ||= '16.04'
-        super(options) do |node|
-          # Allow inserting arbitrary attribute data in to the node
-          node.attributes.default = Chef::Mixin::DeepMerge.merge(node.attributes.default, options[:default_attributes]) if options[:default_attributes]
-          node.attributes.normal = Chef::Mixin::DeepMerge.merge(node.attributes.normal, options[:normal_attributes]) if options[:normal_attributes]
-          node.attributes.override = Chef::Mixin::DeepMerge.merge(node.attributes.override, options[:override_attributes]) if options[:override_attributes]
-          # Store the gemspec for later use
-          @halite_gemspec = options[:halite_gemspec]
-        end
+      def preload!
       end
 
-      def converge(*recipe_names, &block)
-        raise Halite::Error.new('Cannot pass both recipe names and a recipe block to converge') if !recipe_names.empty? && block
-        super(*recipe_names) do
+      def converge(*args, &block)
+        super(*args) do |node|
           add_halite_cookbooks(node, @halite_gemspec) if @halite_gemspec
-          if block
-            cookbook_name = if @halite_gemspec
-              Halite::Gem.new(Array(@halite_gemspec).first).cookbook_name + '_spec'
-            else
-              nil
-            end
-            recipe = Chef::Recipe.new(cookbook_name, nil, run_context)
-            recipe.instance_exec(&block)
-          end
+          block.call(node) if block
         end
       end
 
@@ -96,10 +70,31 @@ module Halite
         end
       end
 
+      # Override the normal cookbook loading behavior.
+      def cookbook
+        if @halite_gemspec
+          halite_gem = Halite::Gem.new(Array(@halite_gemspec).first)
+          Chef::Cookbook::Metadata.new.tap do |metadata|
+            metadata.name(halite_gem.cookbook_name)
+          end
+        else
+          super
+        end
+      end
+
       # Don't try to autodetect the calling cookbook.
-      def calling_cookbook_path(_kaller)
+      def calling_cookbook_path(*args)
         File.expand_path('../empty', __FILE__)
       end
+
+      # Inject a better chefspec_cookbook_root option.
+      def apply_chef_config!
+        super
+        if @halite_gemspec
+          Chef::Config[:chefspec_cookbook_root] = Array(@halite_gemspec).first.full_gem_path
+        end
+      end
+
     end
   end
 end