chefspec 2.0.1 → 3.0.0.beta.1

data/lib/chefspec/api/render_file.rb

@@ -0,0 +1,32 @@
+module ChefSpec::API
+  # @since 3.0.0
+  module RenderFileMatchers
+    #
+    # Assert that a file is rendered by the Chef run. This matcher works for
+    # +template+, +file+, and +cookbook_file+ resources. The content from the
+    # resource must be convertable to a string; verifying the content of a
+    # binary file is not permissible at this time.
+    #
+    # @example Assert a template is rendered
+    #   expect(chef_run).to render_file('/etc/foo')
+    #
+    # @example Assert a template is rendered with certain content
+    #   expect(template).to render_file('/etc/foo').with_content('This is a file')
+    #
+    # @example Assert a template is rendered with matching content
+    #   expect(template).to render_file('/etc/foo').with_content(/^This(.+)$/)
+    #
+    # @example Assert a partial path to a template is rendered with matching content
+    #   expect(template).to render_file(/\/etc\/foo-(\d+)$/).with_content(/^This(.+)$/)
+    #
+    #
+    # @param [String] path
+    #   the path of the file to render
+    #
+    # @return [ChefSpec::Matchers::RenderFileMatcher]
+    #
+    def render_file(path)
+      ChefSpec::Matchers::RenderFileMatcher.new(path)
+    end
+  end
+end

data/lib/chefspec/api/route.rb

@@ -0,0 +1,80 @@
+module ChefSpec::API
+  # @since 3.0.0
+  module RouteMatchers
+    ChefSpec::Runner.define_runner_method :route
+
+    #
+    # Assert that a +route+ resource exists in the Chef run with the
+    # action +:add+. Given a Chef Recipe that adds "10.0.0.10/32" as a
+    # +route+:
+    #
+    #     route '10.0.0.10/32' do
+    #       action :add
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +route+ resource with ChefSpec.
+    #
+    # @example Assert that a +route+ was added
+    #   expect(chef_run).to add_route('10.0.0.10/32')
+    #
+    # @example Assert that a +route+ was added with predicate matchers
+    #   expect(chef_run).to add_route('10.0.0.10/32').with_device('eth0')
+    #
+    # @example Assert that a +route+ was added with attributes
+    #   expect(chef_run).to add_route('10.0.0.10/32').with(device: 'eth0')
+    #
+    # @example Assert that a +route+ was added using a regex
+    #   expect(chef_run).to add_route('10.0.0.10/32').with(device: /eth(\d+)/)
+    #
+    # @example Assert that a +route+ was _not_ added
+    #   expect(chef_run).to_not add_route('10.0.0.10/32')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def add_route(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:route, :add, resource_name)
+    end
+
+    #
+    # Assert that a +route+ resource exists in the Chef run with the
+    # action +:delete+. Given a Chef Recipe that deletes "10.0.0.10/32" as a
+    # +route+:
+    #
+    #     route '10.0.0.10/32' do
+    #       action :delete
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +route+ resource with ChefSpec.
+    #
+    # @example Assert that a +route+ was deleteed
+    #   expect(chef_run).to delete_route('10.0.0.10/32')
+    #
+    # @example Assert that a +route+ was deleteed with predicate matchers
+    #   expect(chef_run).to delete_route('10.0.0.10/32').with_device('eth0')
+    #
+    # @example Assert that a +route+ was deleteed with attributes
+    #   expect(chef_run).to delete_route('10.0.0.10/32').with(device: 'eth0')
+    #
+    # @example Assert that a +route+ was deleteed using a regex
+    #   expect(chef_run).to delete_route('10.0.0.10/32').with(device: /eth(\d+)/)
+    #
+    # @example Assert that a +route+ was _not_ deleteed
+    #   expect(chef_run).to_not delete_route('10.0.0.10/32')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def delete_route(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:route, :delete, resource_name)
+    end
+  end
+end

data/lib/chefspec/api/rpm_package.rb

@@ -0,0 +1,117 @@
+module ChefSpec::API
+  # @since 3.0.0
+  module RpmPackageMatchers
+    ChefSpec::Runner.define_runner_method :rpm_package
+
+    #
+    # Assert that a +rpm_package+ resource exists in the Chef run with the
+    # action +:install+. Given a Chef Recipe that installs "apache2" as a
+    # +rpm_package+:
+    #
+    #     rpm_package 'apache2' do
+    #       action :install
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +rpm_package+ resource with ChefSpec.
+    #
+    # @example Assert that a +rpm_package+ was installed
+    #   expect(chef_run).to install_rpm_package('apache2')
+    #
+    # @example Assert that a +rpm_package+ was installed with predicate matchers
+    #   expect(chef_run).to install_rpm_package('apache2').with_version('1.2.3')
+    #
+    # @example Assert that a +rpm_package+ was installed with attributes
+    #   expect(chef_run).to install_rpm_package('apache2').with(version: '1.2.3')
+    #
+    # @example Assert that a +rpm_package+ was installed using a regex
+    #   expect(chef_run).to install_rpm_package('apache2').with(version: /(\d+\.){2}\.\d+/)
+    #
+    # @example Assert that a +rpm_package+ was _not_ installed
+    #   expect(chef_run).to_not install_rpm_package('apache2')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def install_rpm_package(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:rpm_package, :install, resource_name)
+    end
+
+    #
+    # Assert that a +rpm_package+ resource exists in the Chef run with the
+    # action +:remove+. Given a Chef Recipe that removes "apache2" as a
+    # +rpm_package+:
+    #
+    #     rpm_package 'apache2' do
+    #       action :remove
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +rpm_package+ resource with ChefSpec.
+    #
+    # @example Assert that a +rpm_package+ was removed
+    #   expect(chef_run).to remove_rpm_package('apache2')
+    #
+    # @example Assert that a +rpm_package+ was removed with predicate matchers
+    #   expect(chef_run).to remove_rpm_package('apache2').with_version('1.2.3')
+    #
+    # @example Assert that a +rpm_package+ was removed with attributes
+    #   expect(chef_run).to remove_rpm_package('apache2').with(version: '1.2.3')
+    #
+    # @example Assert that a +rpm_package+ was removed using a regex
+    #   expect(chef_run).to remove_rpm_package('apache2').with(version: /(\d+\.){2}\.\d+/)
+    #
+    # @example Assert that a +rpm_package+ was _not_ removed
+    #   expect(chef_run).to_not remove_rpm_package('apache2')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def remove_rpm_package(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:rpm_package, :remove, resource_name)
+    end
+
+    #
+    # Assert that a +rpm_package+ resource exists in the Chef run with the
+    # action +:upgrade+. Given a Chef Recipe that upgrades "apache2" as a
+    # +rpm_package+:
+    #
+    #     rpm_package 'apache2' do
+    #       action :upgrade
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +rpm_package+ resource with ChefSpec.
+    #
+    # @example Assert that a +rpm_package+ was upgraded
+    #   expect(chef_run).to upgrade_rpm_package('apache2')
+    #
+    # @example Assert that a +rpm_package+ was upgraded with predicate matchers
+    #   expect(chef_run).to upgrade_rpm_package('apache2').with_version('1.2.3')
+    #
+    # @example Assert that a +rpm_package+ was upgraded with attributes
+    #   expect(chef_run).to upgrade_rpm_package('apache2').with(version: '1.2.3')
+    #
+    # @example Assert that a +rpm_package+ was upgraded using a regex
+    #   expect(chef_run).to upgrade_rpm_package('apache2').with(version: /(\d+\.){2}\.\d+/)
+    #
+    # @example Assert that a +rpm_package+ was _not_ upgraded
+    #   expect(chef_run).to_not upgrade_rpm_package('apache2')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def upgrade_rpm_package(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:rpm_package, :upgrade, resource_name)
+    end
+  end
+end

data/lib/chefspec/api/ruby_block.rb

@@ -0,0 +1,37 @@
+module ChefSpec::API
+  # @since 0.5.0
+  module RubyBlockMatchers
+    ChefSpec::Runner.define_runner_method :ruby_block
+
+    #
+    # Assert that a +ruby_block+ resource exists in the Chef run with the
+    # action +:run+. Given a Chef Recipe that runs "do_something" as a
+    # +ruby_block+:
+    #
+    #     ruby_block 'do_something' do
+    #       block do
+    #         # ...
+    #       end
+    #       action :run
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +ruby_block+ resource with ChefSpec.
+    #
+    # @example Assert that a +ruby_block+ was runed
+    #   expect(chef_run).to run_ruby_block('do_something')
+    #
+    # @example Assert that a +ruby_block+ was _not_ runed
+    #   expect(chef_run).to_not run_ruby_block('do_something')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def run_ruby_block(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:ruby_block, :run, resource_name)
+    end
+  end
+end

data/lib/chefspec/api/script.rb

@@ -0,0 +1,228 @@
+module ChefSpec::API
+  # @since 1.0.0
+  module ScriptMatchers
+    ChefSpec::Runner.define_runner_method :script
+
+    #
+    # Assert that a +bash+ resource exists in the Chef run with the
+    # action +:run+. Given a Chef Recipe that runs "command" using
+    # +bash+:
+    #
+    #     bash 'command' do
+    #       action :run
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +bash+ resource with ChefSpec.
+    #
+    # @example Assert that a +bash+ was run
+    #   expect(chef_run).to run_bash('command')
+    #
+    # @example Assert that a +bash+ was run with predicate matchers
+    #   expect(chef_run).to run_bash('command').with_cwd('/home')
+    #
+    # @example Assert that a +bash+ was run with attributes
+    #   expect(chef_run).to run_bash('command').with(cwd: '/home')
+    #
+    # @example Assert that a +bash+ was run using a regex
+    #   expect(chef_run).to run_bash('command').with(cwd: /\/(.+)/)
+    #
+    # @example Assert that a +bash+ was _not_ run
+    #   expect(chef_run).to_not run_bash('command')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def run_bash(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:bash, :run, resource_name)
+    end
+
+    #
+    # Assert that a +csh+ resource exists in the Chef run with the
+    # action +:run+. Given a Chef Recipe that runs "command" using
+    # +csh+:
+    #
+    #     csh 'command' do
+    #       action :run
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +csh+ resource with ChefSpec.
+    #
+    # @example Assert that a +csh+ was run
+    #   expect(chef_run).to run_csh('command')
+    #
+    # @example Assert that a +csh+ was run with predicate matchers
+    #   expect(chef_run).to run_csh('command').with_cwd('/home')
+    #
+    # @example Assert that a +csh+ was run with attributes
+    #   expect(chef_run).to run_csh('command').with(cwd: '/home')
+    #
+    # @example Assert that a +csh+ was run using a regex
+    #   expect(chef_run).to run_csh('command').with(cwd: /\/(.+)/)
+    #
+    # @example Assert that a +csh+ was _not_ run
+    #   expect(chef_run).to_not run_csh('command')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def run_csh(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:csh, :run, resource_name)
+    end
+
+    #
+    # Assert that a +perl+ resource exists in the Chef run with the
+    # action +:run+. Given a Chef Recipe that runs "command" using
+    # +perl+:
+    #
+    #     perl 'command' do
+    #       action :run
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +perl+ resource with ChefSpec.
+    #
+    # @example Assert that a +perl+ was run
+    #   expect(chef_run).to run_perl('command')
+    #
+    # @example Assert that a +perl+ was run with predicate matchers
+    #   expect(chef_run).to run_perl('command').with_cwd('/home')
+    #
+    # @example Assert that a +perl+ was run with attributes
+    #   expect(chef_run).to run_perl('command').with(cwd: '/home')
+    #
+    # @example Assert that a +perl+ was run using a regex
+    #   expect(chef_run).to run_perl('command').with(cwd: /\/(.+)/)
+    #
+    # @example Assert that a +perl+ was _not_ run
+    #   expect(chef_run).to_not run_perl('command')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def run_perl(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:perl, :run, resource_name)
+    end
+
+    #
+    # Assert that a +python+ resource exists in the Chef run with the
+    # action +:run+. Given a Chef Recipe that runs "command" using
+    # +python+:
+    #
+    #     python 'command' do
+    #       action :run
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +python+ resource with ChefSpec.
+    #
+    # @example Assert that a +python+ was run
+    #   expect(chef_run).to run_python('command')
+    #
+    # @example Assert that a +python+ was run with predicate matchers
+    #   expect(chef_run).to run_python('command').with_cwd('/home')
+    #
+    # @example Assert that a +python+ was run with attributes
+    #   expect(chef_run).to run_python('command').with(cwd: '/home')
+    #
+    # @example Assert that a +python+ was run using a regex
+    #   expect(chef_run).to run_python('command').with(cwd: /\/(.+)/)
+    #
+    # @example Assert that a +python+ was _not_ run
+    #   expect(chef_run).to_not run_python('command')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def run_python(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:python, :run, resource_name)
+    end
+
+    #
+    # Assert that a +ruby+ resource exists in the Chef run with the
+    # action +:run+. Given a Chef Recipe that runs "command" using
+    # +ruby+:
+    #
+    #     ruby 'command' do
+    #       action :run
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +ruby+ resource with ChefSpec.
+    #
+    # @example Assert that a +ruby+ was run
+    #   expect(chef_run).to run_ruby('command')
+    #
+    # @example Assert that a +ruby+ was run with predicate matchers
+    #   expect(chef_run).to run_ruby('command').with_cwd('/home')
+    #
+    # @example Assert that a +ruby+ was run with attributes
+    #   expect(chef_run).to run_ruby('command').with(cwd: '/home')
+    #
+    # @example Assert that a +ruby+ was run using a regex
+    #   expect(chef_run).to run_ruby('command').with(cwd: /\/(.+)/)
+    #
+    # @example Assert that a +ruby+ was _not_ run
+    #   expect(chef_run).to_not run_ruby('command')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def run_ruby(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:ruby, :run, resource_name)
+    end
+
+    #
+    # Assert that a +script+ resource exists in the Chef run with the
+    # action +:run+. Given a Chef Recipe that runs "command" using
+    # +script+:
+    #
+    #     script 'command' do
+    #       action :run
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +script+ resource with ChefSpec.
+    #
+    # @example Assert that a +script+ was run
+    #   expect(chef_run).to run_script('command')
+    #
+    # @example Assert that a +script+ was run with predicate matchers
+    #   expect(chef_run).to run_script('command').with_cwd('/home')
+    #
+    # @example Assert that a +script+ was run with attributes
+    #   expect(chef_run).to run_script('command').with(cwd: '/home')
+    #
+    # @example Assert that a +script+ was run using a regex
+    #   expect(chef_run).to run_script('command').with(cwd: /\/(.+)/)
+    #
+    # @example Assert that a +script+ was _not_ run
+    #   expect(chef_run).to_not run_script('command')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def run_script(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:script, :run, resource_name)
+    end
+  end
+end