chefspec-chef 9.3.4

data/lib/chefspec/rspec.rb

@@ -0,0 +1,21 @@
+RSpec.configure do |config|
+  unless ENV["CHEFSPEC_NO_INCLUDE"]
+    config.include(ChefSpec::API)
+  end
+
+  config.add_setting :berkshelf_options, default: {}
+  config.add_setting :policyfile_path
+  config.add_setting :file_cache_path
+  config.add_setting :cookbook_root
+  config.add_setting :cookbook_path
+  config.add_setting :role_path
+  config.add_setting :environment_path
+  config.add_setting :file_cache_path
+  config.add_setting :log_level, default: :warn
+  config.add_setting :path
+  config.add_setting :platform
+  config.add_setting :version
+  config.add_setting :server_runner_data_store, default: :in_memory
+  config.add_setting :server_runner_clear_cookbooks, default: true
+  config.add_setting :server_runner_port, default: (8889..8899)
+end

data/lib/chefspec/runner.rb

@@ -0,0 +1,8 @@
+require_relative "solo_runner"
+
+module ChefSpec
+  # As we start to migrate back to only SoloRunner, include this alias for now.
+  #
+  # @since 7.3
+  Runner = SoloRunner
+end

data/lib/chefspec/server.rb

@@ -0,0 +1,4 @@
+# @todo Remove in v5.0.0
+require_relative "deprecations"
+deprecated "require 'chefspec/server' is no longer required and " \
+  "will be removed in the next major release."

data/lib/chefspec/server_methods.rb

@@ -0,0 +1,173 @@
+module ChefSpec
+  # This module contains the list of methods that are specific to creating and
+  # managing resources within an Chef Zero instance. It is designed to be
+  # included in a class which exposes a `server` instance variable or method
+  # that returns a {ChefZero::Server} instance.
+  module ServerMethods
+    #
+    # The actual Chef Zero Server object.
+    #
+    # @return [ChefZero::Server]
+    #
+    def server
+      ChefSpec::ZeroServer.server
+    end
+
+    #
+    # @macro entity
+    #   @method create_$1(name, data = {})
+    #     Create a new $1 on the Chef Server
+    #
+    #     @param [String] name
+    #       the name of the $1
+    #     @param [Hash] data
+    #       the list of data to load
+    #
+    #
+    #   @method $1(name)
+    #     Find a $1 at the given name
+    #
+    #     @param [String] name
+    #       the name of the $1
+    #
+    #     @return [$2, nil]
+    #
+    #
+    #   @method $3
+    #     The list of $1 on the Chef Server
+    #
+    #     @return [Array<Hash>]
+    #       all the $1 on the Chef Server
+    #
+    #
+    #   @method has_$1?(name)
+    #     Determine if the Chef Server has the given $1
+    #
+    #     @param [String] name
+    #       the name of the $1 to find
+    #
+    #     @return [true, false]
+    #
+    def self.entity(method, klass, key)
+      class_eval <<-EOH, __FILE__, __LINE__ + 1
+        def create_#{method}(name, data = {})
+          # Automatically set the "name" if no explicit one was given
+          data[:name] ||= name
+
+          # Convert it to JSON
+          data = JSON.fast_generate(data)
+
+          load_data(name, '#{key}', data)
+        end
+
+        def get_#{method}(name)
+          data = get('#{key}', name)
+          json = JSON.parse(data)
+
+          case
+          when #{klass}.respond_to?(:json_create)
+            #{klass}.json_create(json)
+          when #{klass}.respond_to?(:from_hash)
+            #{klass}.from_hash(json)
+          else
+            #{klass}.new(json)
+          end
+        rescue ChefZero::DataStore::DataNotFoundError
+          nil
+        end
+
+        def get_#{key}
+          get('#{key}')
+        end
+
+        def has_#{method}?(name)
+          !get('#{key}', name).nil?
+        rescue ChefZero::DataStore::DataNotFoundError
+          false
+        end
+      EOH
+    end
+
+    entity :client,      Chef::Client, "clients"
+    entity :data_bag,    Chef::DataBag, "data"
+    entity :environment, Chef::Environment, "environments"
+    entity :node,        Chef::Node, "nodes"
+    entity :role,        Chef::Role, "roles"
+
+    #
+    # Create a new data_bag on the Chef Server. This overrides the method
+    # created by {entity}
+    #
+    # @param [String] name
+    #   the name of the data bag
+    # @param [Hash] data
+    #   the data to load into the data bag
+    #
+    def create_data_bag(name, data = {})
+      load_data(name, "data", data)
+    end
+
+    #
+    # Create a new node on the Chef Server. This overrides the method created
+    # by {entity}, permitting users to pass a raw +Chef::Node+ object in
+    # addition to a hash.
+    #
+    # @example Create a node from a hash
+    #
+    #   create_node('bacon', attribute: 'value')
+    #
+    # @example Create a node from a +Chef::Node+ object
+    #
+    #   node = stub_node('bacon', platform: 'ubuntu', version: '18.04')
+    #   create_node(node)
+    #
+    # @param [String, Chef::Node] object
+    #   the object to create; this can be the name of the node, or an actual
+    #   +Chef::Node+ object
+    # @param [Hash] data
+    #   the list of data to populate the node with; this is ignored if an
+    #   actual node object is given
+    #
+    def create_node(object, data = {})
+      if object.is_a?(Chef::Node)
+        name = object.name
+        data = object.to_json
+      else
+        name = object.to_s
+        data[:name] ||= name
+        data = JSON.fast_generate(data)
+      end
+
+      load_data(name, "nodes", data)
+    end
+    alias_method :update_node, :create_node
+
+    #
+    # Shortcut method for loading data into Chef Zero.
+    #
+    # @param [String] name
+    #   the name or id of the item to load
+    # @param [String, Symbol] key
+    #   the key to load
+    # @param [Hash] data
+    #   the data for the object, which will be converted to JSON and uploaded
+    #   to the server
+    #
+    def load_data(name, key, data = {})
+      ChefSpec::ZeroServer.load_data(name, key, data)
+    end
+
+    #
+    # Get the path to an item in the data store.
+    #
+    def get(*args)
+      args.unshift("organizations", "chef")
+
+      if args.size == 3
+        server.data_store.list(args)
+      else
+        server.data_store.get(args)
+      end
+    end
+  end
+end

data/lib/chefspec/server_runner.rb

@@ -0,0 +1,76 @@
+require "chef/cookbook_loader"
+require "chef/cookbook_uploader"
+
+require_relative "zero_server"
+require_relative "file_cache_path_proxy"
+require_relative "server_methods"
+require_relative "solo_runner"
+
+module ChefSpec
+  class ServerRunner < SoloRunner
+    include ChefSpec::ServerMethods
+
+    # @see (SoloRunner#initialize)
+    def initialize(options = {})
+      # Unlike the SoloRunner, the file_cache_path needs to remain consistent
+      # for every Chef run or else the Chef client tries to loads the same
+      # cookbook multiple times and will encounter deprecated logic when
+      # creating LWRPs. It also slows down the entire process.
+      options[:file_cache_path] ||= RSpec.configuration.file_cache_path ||
+        ChefSpec::FileCachePathProxy.instance.file_cache_path
+
+      # Call super, but do not pass in the block because we want to customize
+      # our yielding.
+      super(options, &nil)
+
+      # Unlike the SoloRunner, the node AND server object are yielded for
+      # customization
+      yield node, self if block_given?
+    end
+
+    # @see (SoloRunner#converge)
+    def converge(*recipe_names)
+      ChefSpec::ZeroServer.upload_cookbooks!
+
+      super do
+        yield if block_given?
+
+        # Save the node back to the server for searching purposes
+        client.register
+        node.save
+      end
+    end
+
+    private
+
+    #
+    # The path to the insecure Chef Zero private key on disk. Because Chef
+    # requires the path to a file instead of the contents of the key (why),
+    # this method dynamically writes the +ChefZero::PRIVATE_KEY+ to disk and
+    # then returns that path.
+    #
+    # @return [String]
+    #   the path to the client key on disk
+    #
+    def client_key
+      tmp = Dir.mktmpdir
+      path = File.join(tmp, "client.pem")
+      File.open(path, "wb") { |f| f.write(ChefZero::PRIVATE_KEY) }
+      at_exit { FileUtils.rm_rf(tmp) }
+      path
+    end
+
+    # (see SoloRunner#apply_chef_config!)
+    def apply_chef_config!
+      super
+      Chef::Config[:client_key]       = client_key
+      Chef::Config[:client_name]      = "chefspec"
+      Chef::Config[:node_name]        = "chefspec"
+      Chef::Config[:solo]             = false
+      Chef::Config[:solo_legacy_mode] = false
+
+      Chef::Config[:chef_server_url]  = server.url
+      Chef::Config[:http_retry_count] = 0
+    end
+  end
+end