chefspec 2.0.1 → 3.0.0.beta.1

data/lib/chefspec/extensions/chef/securable.rb

@@ -0,0 +1,19 @@
+require 'chef/mixin/securable'
+
+class Chef
+  module Mixin
+    module Securable
+      # In Chef, this module is only included if the RUBY_PLATFORM is
+      # Windows-like. In ChefSpec, we want to include this, regardless of the
+      # platform, becuase this module holds the `inherits` attribute, which is
+      # critical in testing Windows resources.
+      include WindowsSecurableAttributes
+
+      def self.included(including_class)
+        including_class.extend(WindowsMacros)
+        including_class.rights_attribute(:rights)
+        including_class.rights_attribute(:deny_rights)
+      end
+    end
+  end
+end

data/lib/chefspec/formatter.rb

@@ -0,0 +1,270 @@
+require 'chef/formatters/base'
+require 'chef/formatters/error_mapper'
+
+module ChefSpec
+  class ChefFormatter < Chef::Formatters::Base
+    cli_name :chefspec
+
+    # Called at the very start of a Chef Run
+    def run_start(version); end
+
+    def run_started(run_status); end
+
+    # Called at the end a successful Chef run.
+    def run_completed(node); end
+
+    # Called at the end of a failed Chef run.
+    def run_failed(exception); end
+
+    # Called right after ohai runs.
+    def ohai_completed(node); end
+
+    # Already have a client key, assuming this node has registered.
+    def skipping_registration(node_name, config); end
+
+    # About to attempt to register as +node_name+
+    def registration_start(node_name, config); end
+
+    def registration_completed; end
+
+    # Failed to register this client with the server.
+    def registration_failed(node_name, exception, config)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.registration_failed(node_name, exception, config)
+        display_error(description)
+      end
+    end
+
+    # Called before Chef client loads the node data from the server
+    def node_load_start(node_name, config); end
+
+    # Failed to load node data from the server
+    def node_load_failed(node_name, exception, config)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.node_load_failed(node_name, exception, config)
+        display_error(description)
+      end
+    end
+
+    # Error expanding the run list
+    def run_list_expand_failed(node, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.run_list_expand_failed(node, exception)
+        display_error(description)
+      end
+    end
+
+    # Called after Chef client has loaded the node data.
+    # Default and override attrs from roles have been computed, but not yet applied.
+    # Normal attrs from JSON have been added to the node.
+    def node_load_completed(node, expanded_run_list, config); end
+
+    # Called before the cookbook collection is fetched from the server.
+    def cookbook_resolution_start(expanded_run_list); end
+
+    # Called when there is an error getting the cookbook collection from the
+    # server.
+    def cookbook_resolution_failed(expanded_run_list, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.cookbook_resolution_failed(expanded_run_list, exception)
+        display_error(description)
+      end
+    end
+
+    # Called when the cookbook collection is returned from the server.
+    def cookbook_resolution_complete(cookbook_collection); end
+
+    # Called before unneeded cookbooks are removed
+    def cookbook_clean_start; end
+
+    # Called after the file at +path+ is removed. It may be removed if the
+    # cookbook containing it was removed from the run list, or if the file was
+    # removed from the cookbook.
+    def removed_cookbook_file(path); end
+
+    # Called when cookbook cleaning is finished.
+    def cookbook_clean_complete; end
+
+    # Called before cookbook sync starts
+    def cookbook_sync_start(cookbook_count); end
+
+    # Called when cookbook +cookbook_name+ has been sync'd
+    def synchronized_cookbook(cookbook_name); end
+
+    # Called when an individual file in a cookbook has been updated
+    def updated_cookbook_file(cookbook_name, path); end
+
+    # Called when an error occurs during cookbook sync
+    def cookbook_sync_failed(cookbooks, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.cookbook_sync_failed(cookbooks, exception)
+        display_error(description)
+      end
+    end
+
+    # Called after all cookbooks have been sync'd.
+    def cookbook_sync_complete; end
+
+    # Called when library file loading starts
+    def library_load_start(file_count); end
+
+    # Called when library file has been loaded
+    def library_file_loaded(path); end
+
+    # Called when a library file has an error on load.
+    def library_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when library file loading has finished
+    def library_load_complete; end
+
+    # Called when LWRP loading starts
+    def lwrp_load_start(lwrp_file_count); end
+
+    # Called after a LWR or LWP has been loaded
+    def lwrp_file_loaded(path); end
+
+    # Called after a LWR or LWP file errors on load
+    def lwrp_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when LWRPs are finished loading
+    def lwrp_load_complete; end
+
+    # Called before attribute files are loaded
+    def attribute_load_start(attribute_file_count); end
+
+    # Called after the attribute file is loaded
+    def attribute_file_loaded(path); end
+
+    # Called when an attribute file fails to load.
+    def attribute_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when attribute file loading is finished
+    def attribute_load_complete; end
+
+    # Called before resource definitions are loaded
+    def definition_load_start(definition_file_count); end
+
+    # Called when a resource definition has been loaded
+    def definition_file_loaded(path); end
+
+    # Called when a resource definition file fails to load
+    def definition_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when resource defintions are done loading
+    def definition_load_complete; end
+
+    # Called before recipes are loaded
+    def recipe_load_start(recipe_count); end
+
+    # Called after the recipe has been loaded
+    def recipe_file_loaded(path); end
+
+    # Called after a recipe file fails to load
+    def recipe_file_load_failed(path, exception)
+      file_load_failed(path, exception)
+    end
+
+    # Called when a recipe cannot be resolved
+    def recipe_not_found(exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.file_load_failed(nil, exception)
+        display_error(description)
+      end
+    end
+
+    # Called when recipes have been loaded.
+    def recipe_load_complete; end
+
+    # Called before convergence starts
+    def converge_start(run_context); end
+
+    # Called when the converge phase is finished.
+    def converge_complete; end
+
+    # Called before action is executed on a resource.
+    def resource_action_start(resource, action, notification_type=nil, notifier=nil); end
+
+    # Called when a resource fails, but will retry.
+    def resource_failed_retriable(resource, action, retry_count, exception); end
+
+    # Called when a resource fails and will not be retried.
+    def resource_failed(resource, action, exception)
+      expecting_exception(exception) do
+        description = Chef::Formatters::ErrorMapper.resource_failed(resource, action, exception)
+        display_error(description)
+      end
+    end
+
+    # Called when a resource action has been skipped b/c of a conditional
+    def resource_skipped(resource, action, conditional); end
+
+    # Called when a resource action has been completed
+    def resource_completed(resource); end
+
+    # Called after #load_current_resource has run.
+    def resource_current_state_loaded(resource, action, current_resource); end
+
+    # Called when resource current state load is skipped due to the provider
+    # not supporting whyrun mode.
+    def resource_current_state_load_bypassed(resource, action, current_resource); end
+
+    # Called when evaluating a resource that does not support whyrun in whyrun mode
+    def resource_bypassed(resource, action, current_resource); end
+
+    # Called when a resource has no converge actions, e.g., it was already correct.
+    def resource_up_to_date(resource, action); end
+
+    # Called when a change has been made to a resource. May be called multiple
+    # times per resource, e.g., a file may have its content updated, and then
+    # its permissions updated.
+    def resource_update_applied(resource, action, update); end
+
+    # Called after a resource has been completely converged, but only if
+    # modifications were made.
+    def resource_updated(resource, action); end
+
+    # Called before handlers run
+    def handlers_start(handler_count); end
+
+    # Called after an individual handler has run
+    def handler_executed(handler); end
+
+    # Called after all handlers have executed
+    def handlers_completed; end
+
+    # Called when an assertion declared by a provider fails
+    def provider_requirement_failed(action, resource, exception, message); end
+
+    # Called when a provider makes an assumption after a failed assertion
+    # in whyrun mode, in order to allow execution to continue
+    def whyrun_assumption(action, resource, message); end
+
+    # An uncategorized message. This supports the case that a user needs to
+    # pass output that doesn't fit into one of the callbacks above. Note that
+    # there's no semantic information about the content or importance of the
+    # message. That means that if you're using this too often, you should add a
+    # callback for it.
+    def msg(message); end
+
+    private
+      def file_load_failed(path, exception)
+        expecting_exception(exception) do
+          description = Chef::Formatters::ErrorMapper.file_load_failed(path, exception)
+          display_error(description)
+        end
+      end
+
+      def expecting_exception(exception, &block)
+        yield unless ChefSpec::ExpectException.new(exception).expected?
+      end
+
+  end
+end

data/lib/chefspec/macros.rb

@@ -0,0 +1,217 @@
+module ChefSpec
+  module Macros
+    extend self
+
+    #
+    # The name of the currently running cookbook spec. Given the top-level
+    # +describe+ block is of the format:
+    #
+    #     describe 'my_cookbook::my_recipe' do
+    #       # ...
+    #     end
+    #
+    # The value of +described_cookbook+ is "my_cookbook".
+    #
+    # @example Using +described_cookbook+ in a context block
+    #   context "#{described_recipe} installs foo" do
+    #     # ...
+    #   end
+    #
+    #
+    # @return [String]
+    #
+    def described_cookbook
+      described_recipe.split('::').first
+    end
+
+    #
+    # The name of the currently running recipe spec. Given the top-level
+    # +describe+ block is of the format:
+    #
+    #     describe 'my_cookbook::my_recipe' do
+    #       # ...
+    #     end
+    #
+    # The value of +described_recipe+ is "my_cookbook::my_recipe".
+    #
+    # @example Using +described_recipe+ in the +ChefSpec::Runner+
+    #   let(:chef_run) { ChefSpec::Runner.new.converge(described_recipe) }
+    #
+    #
+    # @return [String]
+    #
+    def described_recipe
+      scope = self.is_a?(Class) ? self : self.class
+
+      metahash = scope.metadata
+      while metahash.has_key?(:example_group)
+        metahash = metahash[:example_group]
+      end
+
+      metahash[:description_args].first.to_s
+    end
+
+    #
+    # Stub a shell command to return a particular value without
+    # shelling out to the system.
+    #
+    # @example stubbing a command to return true
+    #   stub_command('test -f /tmp/bacon').and_return(true)
+    #
+    # @example stubbing a block that is evaluated at runtime
+    #   stub_command('test -f /tmp/bacon') { MyClass.check? }
+    #
+    # @example stubbing a command that matches a pattern
+    #   stub_command(/test \-f/).and_return(true)
+    #
+    # @example stubbing a command that raises an exception
+    #   stub_command('test -f /tmp/bacon').and_raise(SomeException)
+    #
+    #
+    # @param [String, Regexp] command
+    #   the command to stub
+    #
+    # @return [ChefSpec::CommandStub]
+    #
+    def stub_command(command, &block)
+      Stubs::CommandRegistry.register(Stubs::CommandStub.new(command, &block))
+    end
+
+    #
+    # Stub a Chef call to load a data_bag.
+    #
+    # @example stubbing a data_bag to return an empty Array
+    #   stub_data_bag('users').and_return([])
+    #
+    # @example stubbing a data_bag with a block that is evaluated at runtime
+    #   stub_data_bag('users') { JSON.parse(File.read('fixtures/data_bag.json')) }
+    #
+    # @example stubbing a data_bag to return an Array of Hashes
+    #   stub_data_bag('users').and_return([
+    #     { id: 'bacon', comment: 'delicious' },
+    #     { id: 'ham', comment: 'also good' }
+    #   ])
+    #
+    # @example stubbing a data_bag to raise an exception
+    #   stub_data_bag('users').and_raise(Chef::Exceptions::PrivateKeyMissing)
+    #
+    #
+    # @param [String, Symbol] bag
+    #   the name of the data bag to stub
+    #
+    # @return [ChefSpec::DataBagStub]
+    #
+    def stub_data_bag(bag, &block)
+      Stubs::DataBagRegistry.register(Stubs::DataBagStub.new(bag, &block))
+    end
+
+    #
+    # Stub a Chef data_bag call.
+    #
+    # @example stubbing a data_bag_item to return a Hash of data
+    #   stub_data_bag_item('users', 'svargo').and_return({
+    #     id: 'svargo',
+    #     name: 'Seth Vargo'
+    #   })
+    #
+    # @example stubbing a data_bag_item with a block that is evaluated at runtime
+    #   stub_data_bag_item('users', 'svargo') { JSON.parse(File.read('fixtures/data_bag_item.json')) }
+    #
+    # @example stubbing a data_bag_item to raise an exception
+    #   stub_data_bag('users', 'svargo').and_raise(Chef::Exceptions::PrivateKeyMissing)
+    #
+    #
+    # @param [String, Symbol] bag
+    #   the name of the data bag to find the item in
+    # @param [String] id
+    #   the id of the data bag item to stub
+    #
+    # @return [ChefSpec::DataBagItemStub]
+    #
+    def stub_data_bag_item(bag, id, &block)
+      Stubs::DataBagItemRegistry.register(Stubs::DataBagItemStub.new(bag, id, &block))
+    end
+
+    #
+    # Creates a fake Chef::Node for use in testing.
+    #
+    # @example mocking a simple node
+    #   stub_node('mynode.example')
+    #
+    # @example mocking a specific platform and version
+    #   stub_node('mynode.example', platform: 'ubuntu', version: '12.04')
+    #
+    # @example overriding a specific ohai attribute
+    #   stub_node('mynode.example', ohai: { ipaddress: '1.2.3.4' })
+    #
+    # @example stubbing a node based on a JSON fixture
+    #   stub_node('mynode.example', path: File.join('fixtures', 'nodes', 'default.json'))
+    #
+    # @example setting specific attributes
+    #   stub_node('mynode.example') do |node|
+    #     node.default['attribute']['thing'] = 'value'
+    #   end
+    #
+    #
+    # @param [String] name
+    #   the name of the node
+    # @param [Hash] options
+    #   the list of options for the node
+    #
+    # @option options [Symbol] :platform
+    #   the platform to mock
+    # @option options [Symbol] :version
+    #   the version of the platform to mock
+    # @option options [Symbol] :path
+    #   filepath to a JSON file to pull a node from
+    # @option options [Hash] :ohai
+    #   a Hash of Ohai attributes to mock on the node
+    #
+    def stub_node(name = 'node.example', options = {}, &block)
+      fauxhai = Fauxhai.mock(options).data
+      fauxhai = fauxhai.merge(options[:ohai] || {})
+      fauxhai = Mash.new(fauxhai)
+
+      node = Chef::Node.new
+      node.name(name)
+      node.automatic_attrs = fauxhai
+      node.instance_eval(&block) if block_given?
+      node
+    end
+
+    #
+    # Stub a Chef search to return pre-defined data. When providing a value,
+    # the value is automatically mashified (to the best of ChefSpec's abilities)
+    # to ease in use.
+    #
+    # @example stubbing a search to return nothing
+    #   stub_search(:node)
+    #
+    # @example stubbing a search with a query
+    #   stub_search(:node, 'name:*')
+    #
+    # @example stubbing a search with a query as a regex
+    #   stub_search(:node, /name:(.+)/)
+    #
+    # @example stubbing a search with a block that is evaluated at runtime
+    #   stub_search(:node) { JSON.parse(File.read('fixtures/nodes.json')) }
+    #
+    # @example stubbing a search to return a fixed value
+    #   stub_search(:node).and_return([ { a: 'b' } ])
+    #
+    # @example stubbing a search to raise an exception
+    #   stub_search(:node).and_raise(Chef::Exceptions::PrivateKeyMissing)
+    #
+    #
+    # @param [String, Symbol] type
+    #   the type to search to stub
+    # @param [String, Symbol, nil] query
+    #   the query to stub
+    #
+    # @return [ChefSpec::SearchStub]
+    #
+    def stub_search(type, query = '*:*', &block)
+      Stubs::SearchRegistry.register(Stubs::SearchStub.new(type, query, &block))
+    end
+  end
+end