chefspec 4.0.2 → 4.1.0

data/lib/chefspec/server_methods.rb

@@ -0,0 +1,175 @@
+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
+      @server ||= ChefZero::Server.new(
+        # Set the log level from RSpec, defaulting to warn
+        log_level:  RSpec.configuration.log_level || :warn,
+
+        # Set a random port so ChefSpec may be run in multiple contexts
+        port: port,
+      )
+    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)
+
+          if #{klass}.respond_to?(:json_create)
+            #{klass}.json_create(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: '12.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
+
+    #
+    # 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 = {})
+      @server.load_data({ key => { name => 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,86 @@
+require 'chef_zero/server'
+require 'chef/cookbook_loader'
+require 'chef/cookbook_uploader'
+
+require_relative 'server_methods'
+require_relative 'solo_runner'
+
+module ChefSpec
+  class ServerRunner < SoloRunner
+    include ChefSpec::ServerMethods
+
+    # @see (SoloRunner#initialize)
+    def initialize(options = {})
+      # Call super, but do not pass in the block because we want to customize
+      # our yielding.
+      super(options, &nil)
+
+      Chef::Config[:client_key]      = client_key
+      Chef::Config[:client_name]     = 'chefspec'
+      Chef::Config[:node_name]       = 'chefspec'
+      Chef::Config[:solo]            = false
+
+      Chef::Config[:chef_server_url]  = server.url
+      Chef::Config[:http_retry_count] = 0
+
+      # Start the Chef Zero instance in the background
+      server.start_background
+      at_exit { server.stop if server.running? }
+
+      # Unlike the SoloRunner, the node AND server object are yielded for
+      # customization
+      yield node, self if block_given?
+    end
+
+    #
+    # Upload the cookbooks to the Chef Server.
+    #
+    def upload_cookbooks!
+      loader = Chef::CookbookLoader.new(Chef::Config[:cookbook_path])
+      loader.load_cookbooks
+
+      uploader = Chef::CookbookUploader.new(loader.cookbooks, loader.cookbook_paths)
+      uploader.upload_cookbooks
+    end
+
+    # @see (SoloRunner#converge)
+    def converge(*recipe_names)
+      upload_cookbooks!
+      super
+    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
+
+    #
+    # A randomly assigned, open port for run the Chef Zero server.
+    #
+    # @return [Fixnum]
+    #
+    def port
+      return @port if @port
+
+      @server = TCPServer.new('127.0.0.1', 0)
+      @port   = @server.addr[1].to_i
+      @server.close
+
+      return @port
+    end
+  end
+end

data/lib/chefspec/{runner.rb → solo_runner.rb}

@@ -5,25 +5,22 @@ require 'chef/providers'
 require 'chef/resources'
 
 module ChefSpec
-  class Runner
-    include ChefSpec::Normalize
-
+  class SoloRunner
     #
-    # Defines a new runner method on the +ChefSpec::Runner+.
+    # Handy class method for just converging a runner if you do not care about
+    # initializing the runner with custom options.
     #
-    # @param [Symbol] resource_name
-    #   the name of the resource to define a method
+    # @example
+    #   ChefSpec::SoloRunner.converge('cookbook::recipe')
     #
-    # @return [self]
-    #
-    def self.define_runner_method(resource_name)
-      define_method(resource_name) do |identity|
-        find_resource(resource_name, identity)
+    def self.converge(*recipe_names)
+      new.tap do |instance|
+        instance.converge(*recipe_names)
       end
-
-      self
     end
 
+    include ChefSpec::Normalize
+
     # @return [Hash]
     attr_reader :options
 
@@ -31,19 +28,19 @@ module ChefSpec
     attr_reader :run_context
 
     #
-    # Instantiate a new Runner to run examples with.
+    # Instantiate a new SoloRunner to run examples with.
     #
     # @example Instantiate a new Runner
-    #   ChefSpec::Runner.new
+    #   ChefSpec::SoloRunner.new
     #
     # @example Specifying the platform and version
-    #   ChefSpec::Runner.new(platform: 'ubuntu', version: '12.04')
+    #   ChefSpec::SoloRunner.new(platform: 'ubuntu', version: '12.04')
     #
     # @example Specifying the cookbook path
-    #   ChefSpec::Runner.new(cookbook_path: ['/cookbooks'])
+    #   ChefSpec::SoloRunner.new(cookbook_path: ['/cookbooks'])
     #
     # @example Specifying the log level
-    #   ChefSpec::Runner.new(log_level: :info)
+    #   ChefSpec::SoloRunner.new(log_level: :info)
     #
     #
     # @param [Hash] options
@@ -62,35 +59,32 @@ module ChefSpec
     #
     # @yield [node] Configuration block for Chef::Node
     #
-    def initialize(options = {}, &block)
-      @options = options = {
-        cookbook_path: RSpec.configuration.cookbook_path || calling_cookbook_path(caller),
-        role_path:     RSpec.configuration.role_path || default_role_path,
-        log_level:     RSpec.configuration.log_level,
-        path:          RSpec.configuration.path,
-        platform:      RSpec.configuration.platform,
-        version:       RSpec.configuration.version,
-      }.merge(options)
+    def initialize(options = {})
+      @options = with_default_options(options)
 
-      Chef::Log.level = options[:log_level]
+      Chef::Log.level = @options[:log_level]
 
       Chef::Config.reset!
       Chef::Config.formatters.clear
       Chef::Config.add_formatter('chefspec')
-      Chef::Config[:cache_type]     = 'Memory'
-      Chef::Config[:client_key]     = nil
-      Chef::Config[:cookbook_path]  = Array(options[:cookbook_path])
-      Chef::Config[:no_lazy_load]   = true
-      Chef::Config[:role_path]      = Array(options[:role_path])
-      Chef::Config[:force_logger]   = true
-      Chef::Config[:solo]           = true
+      Chef::Config[:cache_type]      = 'Memory'
+      Chef::Config[:client_key]      = nil
+      Chef::Config[:client_name]     = nil
+      Chef::Config[:node_name]       = nil
+      Chef::Config[:file_cache_path] = file_cache_path
+      Chef::Config[:cookbook_path]   = Array(@options[:cookbook_path])
+      Chef::Config[:no_lazy_load]    = true
+      Chef::Config[:role_path]       = Array(@options[:role_path])
+      Chef::Config[:force_logger]    = true
+      Chef::Config[:solo]            = true
 
       yield node if block_given?
     end
 
     #
     # Execute the given `run_list` on the node, without actually converging
-    # the node.
+    # the node. Each time {#converge} is called, the `run_list` is reset to the
+    # new value (it is **not** additive).
     #
     # @example Converging a single recipe
     #   chef_run.converge('example::default')
@@ -102,7 +96,7 @@ module ChefSpec
     # @param [Array] recipe_names
     #   The names of the recipe or recipes to converge
     #
-    # @return [ChefSpec::Runner]
+    # @return [ChefSpec::SoloRunner]
     #   A reference to the calling Runner (for chaining purposes)
     #
     def converge(*recipe_names)
@@ -203,7 +197,7 @@ module ChefSpec
     # Boolean method to determine the current phase of the Chef run (compiling
     # or converging)
     #
-    # @return [Boolean]
+    # @return [true, false]
     #
     def compiling?
       !@converging
@@ -221,7 +215,7 @@ module ChefSpec
     # @param [Chef::Resource] resource
     #   the Chef resource to try and step in to
     #
-    # @return [Boolean]
+    # @return [true, false]
     #
     def step_into?(resource)
       key = resource_name(resource)
@@ -231,7 +225,7 @@ module ChefSpec
     #
     # Boolean method to determine if this Runner is in `dry_run` mode.
     #
-    # @return [Boolean]
+    # @return [true, false]
     #
     def dry_run?
       !!options[:dry_run]
@@ -244,8 +238,7 @@ module ChefSpec
     # may change between versions of this gem.
     #
     def to_s
-      return "chef_run: #{node.run_list.to_s}" unless node.run_list.empty?
-      'chef_run'
+      "#<#{self.class.name} run_list: [#{node.run_list}]>"
     end
 
     #
@@ -254,11 +247,67 @@ module ChefSpec
     # @return [String]
     #
     def inspect
-      "#<#{self.class} options: #{options.inspect}, run_list: '#{node.run_list.to_s}'>"
+      "#<#{self.class.name}" \
+      " options: #{options.inspect}," \
+      " run_list: [#{node.run_list}]>"
+    end
+
+    #
+    # Respond to custom matchers defined by the user.
+    #
+    def method_missing(m, *args, &block)
+      if block = ChefSpec.matchers[resource_name(m.to_sym)]
+        instance_exec(args.first, &block)
+      else
+        super
+      end
+    end
+
+    #
+    # Inform Ruby that we respond to methods that are defined as custom
+    # matchers.
+    #
+    def respond_to_missing?(m, include_private = false)
+      ChefSpec.matchers.key?(m.to_sym) || super
     end
 
     private
 
+    #
+    # The path to cache files on disk. This value is created using
+    # {Dir.mktmpdir}. The method adds a {Kernel.at_exit} handler to ensure the
+    # temporary directory is deleted when the system exits.
+    #
+    # **This method creates a new temporary directory on each call!** As such,
+    # you should cache the result to a variable inside you system.
+    #
+    def file_cache_path
+      path = Dir.mktmpdir
+      at_exit { FileUtils.rm_rf(path) }
+      path
+    end
+
+    #
+    # Set the default options, with the given options taking precedence.
+    #
+    # @param [Hash] options
+    #   the list of options to take precedence
+    #
+    # @return [Hash] options
+    #
+    def with_default_options(options)
+      config = RSpec.configuration
+
+      {
+        cookbook_path: config.cookbook_path || calling_cookbook_path(caller),
+        role_path:     config.role_path || default_role_path,
+        log_level:     config.log_level,
+        path:          config.path,
+        platform:      config.platform,
+        version:       config.version,
+      }.merge(options)
+    end
+
     #
     # The inferred path from the calling spec.
     #