chefspec 2.0.1 → 3.0.0.beta.1

data/lib/chefspec/api/link.rb

@@ -0,0 +1,102 @@
+module ChefSpec::API
+  # @since 1.1.0
+  module LinkMatchers
+    ChefSpec::Runner.define_runner_method :link
+
+    #
+    # Assert that a +link+ resource exists in the Chef run with the
+    # action +:create+. Given a Chef Recipe that creates "/tmp" as a
+    # +link+:
+    #
+    #     link '/tmp' do
+    #       action :create
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +link+ resource with ChefSpec.
+    #
+    # @example Assert that a +link+ was createed
+    #   expect(chef_run).to create_link('/tmp')
+    #
+    # @example Assert that a +link+ was createed with predicate matchers
+    #   expect(chef_run).to create_link('/tmp').with_link_type(:hard)
+    #
+    # @example Assert that a +link+ was createed with attributes
+    #   expect(chef_run).to create_link('/tmp').with(link_type: :hard)
+    #
+    # @example Assert that a +link+ was createed using a regex
+    #   expect(chef_run).to create_link('/tmp').with(link_type: Symbol)
+    #
+    # @example Assert that a +link+ was _not_ createed
+    #   expect(chef_run).to_not create_link('/tmp')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def create_link(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:link, :create, resource_name)
+    end
+
+    #
+    # Assert that a +link+ resource exists in the Chef run with the
+    # action +:delete+. Given a Chef Recipe that deletes "/tmp" as a
+    # +link+:
+    #
+    #     link '/tmp' do
+    #       action :delete
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +link+ resource with ChefSpec.
+    #
+    # @example Assert that a +link+ was deleteed
+    #   expect(chef_run).to delete_link('/tmp')
+    #
+    # @example Assert that a +link+ was deleteed with predicate matchers
+    #   expect(chef_run).to delete_link('/tmp').with_link_type(:hard)
+    #
+    # @example Assert that a +link+ was deleteed with attributes
+    #   expect(chef_run).to delete_link('/tmp').with(link_type: :hard)
+    #
+    # @example Assert that a +link+ was deleteed using a regex
+    #   expect(chef_run).to delete_link('/tmp').with(link_type: Symbol)
+    #
+    # @example Assert that a +link+ was _not_ deleteed
+    #   expect(chef_run).to_not delete_link('/tmp')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def delete_link(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:link, :delete, resource_name)
+    end
+
+    #
+    # Assert that a symlink links to a specific path. This is really
+    # syntactic sugar for the following:
+    #
+    #       expect(chef_run).to create_link('/tmp/thing').with(to: '/tmp/other_thing')
+    #
+    # @example Using +link_to+ with a String path
+    #   link = chef_run.link('/tmp/thing')
+    #   expect(link).to link_to('/tmp/other_thing')
+    #
+    # @example Using +link_to+ with a regular expression
+    #   expect(link).to link_to(/\/tmp/(.+)/)
+    #
+    # @param [String, Regex] path
+    #   the path to link to
+    #
+    # @return [ChefSpec::Matchers::LinkToMatcher]
+    #
+    def link_to(path)
+      ChefSpec::Matchers::LinkToMatcher.new(path)
+    end
+  end
+end

data/lib/chefspec/api/log.rb

@@ -0,0 +1,43 @@
+module ChefSpec::API
+  # @since 3.0.0
+  module LogMatchers
+    ChefSpec::Runner.define_runner_method :log
+
+    #
+    # Assert that a +log+ resource exists in the Chef run with the
+    # action +:write+. Given a Chef Recipe that writes "message" as a
+    # +log+:
+    #
+    #     log 'message' do
+    #       action :write
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +log+ resource with ChefSpec.
+    #
+    # @example Assert that a +log+ was writeed
+    #   expect(chef_run).to write_log('message')
+    #
+    # @example Assert that a +log+ was writeed with predicate matchers
+    #   expect(chef_run).to write_log('message').with_level(:info)
+    #
+    # @example Assert that a +log+ was writeed with attributes
+    #   expect(chef_run).to write_log('message').with(level: :info)
+    #
+    # @example Assert that a +log+ was writeed using a regex
+    #   expect(chef_run).to write_log('message').with(level: Symbol)
+    #
+    # @example Assert that a +log+ was _not_ writeed
+    #   expect(chef_run).to_not write_log('message')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def write_log(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:log, :write, resource_name)
+    end
+  end
+end

data/lib/chefspec/api/macports_package.rb

@@ -0,0 +1,154 @@
+module ChefSpec::API
+  # @since 3.0.0
+  module MacportsPackageMatchers
+    ChefSpec::Runner.define_runner_method :macports_package
+
+    #
+    # Assert that a +macports_package+ resource exists in the Chef run with the
+    # action +:install+. Given a Chef Recipe that installs "community-zero" as a
+    # +macports_package+:
+    #
+    #     macports_package 'community-zero' do
+    #       action :install
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +macports_package+ resource with ChefSpec.
+    #
+    # @example Assert that a +macports_package+ was installed
+    #   expect(chef_run).to install_macports_package('community-zero')
+    #
+    # @example Assert that a +macports_package+ was installed with predicate matchers
+    #   expect(chef_run).to install_macports_package('community-zero').with_version('1.2.3')
+    #
+    # @example Assert that a +macports_package+ was installed with attributes
+    #   expect(chef_run).to install_macports_package('community-zero').with(version: '1.2.3')
+    #
+    # @example Assert that a +macports_package+ was installed using a regex
+    #   expect(chef_run).to install_macports_package('community-zero').with(version: /(\d+\.){2}\.\d+/)
+    #
+    # @example Assert that a +macports_package+ was _not_ installed
+    #   expect(chef_run).to_not install_macports_package('community-zero')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def install_macports_package(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:macports_package, :install, resource_name)
+    end
+
+    #
+    # Assert that a +macports_package+ resource exists in the Chef run with the
+    # action +:purge+. Given a Chef Recipe that purges "community-zero" as a
+    # +macports_package+:
+    #
+    #     macports_package 'community-zero' do
+    #       action :purge
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +macports_package+ resource with ChefSpec.
+    #
+    # @example Assert that a +macports_package+ was purgeed
+    #   expect(chef_run).to purge_macports_package('community-zero')
+    #
+    # @example Assert that a +macports_package+ was purgeed with predicate matchers
+    #   expect(chef_run).to purge_macports_package('community-zero').with_version('1.2.3')
+    #
+    # @example Assert that a +macports_package+ was purgeed with attributes
+    #   expect(chef_run).to purge_macports_package('community-zero').with(version: '1.2.3')
+    #
+    # @example Assert that a +macports_package+ was purgeed using a regex
+    #   expect(chef_run).to purge_macports_package('community-zero').with(version: /(\d+\.){2}\.\d+/)
+    #
+    # @example Assert that a +macports_package+ was _not_ purgeed
+    #   expect(chef_run).to_not purge_macports_package('community-zero')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def purge_macports_package(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:macports_package, :purge, resource_name)
+    end
+
+    #
+    # Assert that a +macports_package+ resource exists in the Chef run with the
+    # action +:remove+. Given a Chef Recipe that removes "community-zero" as a
+    # +macports_package+:
+    #
+    #     macports_package 'community-zero' do
+    #       action :remove
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +macports_package+ resource with ChefSpec.
+    #
+    # @example Assert that a +macports_package+ was removeed
+    #   expect(chef_run).to remove_macports_package('community-zero')
+    #
+    # @example Assert that a +macports_package+ was removeed with predicate matchers
+    #   expect(chef_run).to remove_macports_package('community-zero').with_version('1.2.3')
+    #
+    # @example Assert that a +macports_package+ was removeed with attributes
+    #   expect(chef_run).to remove_macports_package('community-zero').with(version: '1.2.3')
+    #
+    # @example Assert that a +macports_package+ was removeed using a regex
+    #   expect(chef_run).to remove_macports_package('community-zero').with(version: /(\d+\.){2}\.\d+/)
+    #
+    # @example Assert that a +macports_package+ was _not_ removeed
+    #   expect(chef_run).to_not remove_macports_package('community-zero')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def remove_macports_package(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:macports_package, :remove, resource_name)
+    end
+
+    #
+    # Assert that a +macports_package+ resource exists in the Chef run with the
+    # action +:upgrade+. Given a Chef Recipe that upgrades "community-zero" as a
+    # +macports_package+:
+    #
+    #     macports_package 'community-zero' do
+    #       action :upgrade
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +macports_package+ resource with ChefSpec.
+    #
+    # @example Assert that a +macports_package+ was upgradeed
+    #   expect(chef_run).to upgrade_macports_package('community-zero')
+    #
+    # @example Assert that a +macports_package+ was upgradeed with predicate matchers
+    #   expect(chef_run).to upgrade_macports_package('community-zero').with_version('1.2.3')
+    #
+    # @example Assert that a +macports_package+ was upgradeed with attributes
+    #   expect(chef_run).to upgrade_macports_package('community-zero').with(version: '1.2.3')
+    #
+    # @example Assert that a +macports_package+ was upgradeed using a regex
+    #   expect(chef_run).to upgrade_macports_package('community-zero').with(version: /(\d+\.){2}\.\d+/)
+    #
+    # @example Assert that a +macports_package+ was _not_ upgradeed
+    #   expect(chef_run).to_not upgrade_macports_package('community-zero')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def upgrade_macports_package(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:macports_package, :upgrade, resource_name)
+    end
+  end
+end

data/lib/chefspec/api/mdadm.rb

@@ -0,0 +1,117 @@
+module ChefSpec::API
+  # @since 3.0.0
+  module MdadmMatchers
+    ChefSpec::Runner.define_runner_method :mdadm
+
+    #
+    # Assert that a +mdadm+ resource exists in the Chef run with the
+    # action +:assemble+. Given a Chef Recipe that assembles "/dev/md0" as a
+    # +mdadm+:
+    #
+    #     mdadm '/dev/md0' do
+    #       action :assemble
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mdadm+ resource with ChefSpec.
+    #
+    # @example Assert that a +mdadm+ was assembled
+    #   expect(chef_run).to assemble_mdadm('/dev/md0')
+    #
+    # @example Assert that a +mdadm+ was assembled with predicate matchers
+    #   expect(chef_run).to assemble_mdadm('/dev/md0').with_devices(['/dev/sda'])
+    #
+    # @example Assert that a +mdadm+ was assembled with attributes
+    #   expect(chef_run).to assemble_mdadm('/dev/md0').with(devices: ['/dev/sda'])
+    #
+    # @example Assert that a +mdadm+ was assembled using a regex
+    #   expect(chef_run).to assemble_mdadm('/dev/md0').with(devices: '/dev/sda')
+    #
+    # @example Assert that a +mdadm+ was _not_ assembled
+    #   expect(chef_run).to_not assemble_mdadm('/dev/md0')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def assemble_mdadm(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mdadm, :assemble, resource_name)
+    end
+
+    #
+    # Assert that a +mdadm+ resource exists in the Chef run with the
+    # action +:create+. Given a Chef Recipe that creates "/dev/md0" as a
+    # +mdadm+:
+    #
+    #     mdadm '/dev/md0' do
+    #       action :create
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mdadm+ resource with ChefSpec.
+    #
+    # @example Assert that a +mdadm+ was createed
+    #   expect(chef_run).to create_mdadm('/dev/md0')
+    #
+    # @example Assert that a +mdadm+ was createed with predicate matchers
+    #   expect(chef_run).to create_mdadm('/dev/md0').with_devices(['/dev/sda'])
+    #
+    # @example Assert that a +mdadm+ was createed with attributes
+    #   expect(chef_run).to create_mdadm('/dev/md0').with(devices: ['/dev/sda'])
+    #
+    # @example Assert that a +mdadm+ was createed using a regex
+    #   expect(chef_run).to create_mdadm('/dev/md0').with(devices: '/dev/sda')
+    #
+    # @example Assert that a +mdadm+ was _not_ createed
+    #   expect(chef_run).to_not create_mdadm('/dev/md0')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def create_mdadm(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mdadm, :create, resource_name)
+    end
+
+    #
+    # Assert that a +mdadm+ resource exists in the Chef run with the
+    # action +:stop+. Given a Chef Recipe that stops "/dev/md0" as a
+    # +mdadm+:
+    #
+    #     mdadm '/dev/md0' do
+    #       action :stop
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mdadm+ resource with ChefSpec.
+    #
+    # @example Assert that a +mdadm+ was stopped
+    #   expect(chef_run).to stop_mdadm('/dev/md0')
+    #
+    # @example Assert that a +mdadm+ was stopped with predicate matchers
+    #   expect(chef_run).to stop_mdadm('/dev/md0').with_devices(['/dev/sda'])
+    #
+    # @example Assert that a +mdadm+ was stopped with attributes
+    #   expect(chef_run).to stop_mdadm('/dev/md0').with(devices: ['/dev/sda'])
+    #
+    # @example Assert that a +mdadm+ was stopped using a regex
+    #   expect(chef_run).to stop_mdadm('/dev/md0').with(devices: '/dev/sda')
+    #
+    # @example Assert that a +mdadm+ was _not_ stopped
+    #   expect(chef_run).to_not stop_mdadm('/dev/md0')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def stop_mdadm(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mdadm, :stop, resource_name)
+    end
+  end
+end

data/lib/chefspec/api/mount.rb

@@ -0,0 +1,192 @@
+module ChefSpec::API
+  # @since 3.0.0
+  module MountMatchers
+    ChefSpec::Runner.define_runner_method :mount
+
+    #
+    # Assert that a +mount+ resource exists in the Chef run with the
+    # action +:disable+. Given a Chef Recipe that disables "/mnt/volume1" as a
+    # +mount+:
+    #
+    #     mount '/mnt/volume1' do
+    #       action :disable
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mount+ resource with ChefSpec.
+    #
+    # @example Assert that a +mount+ was disableed
+    #   expect(chef_run).to disable_mount('/mnt/volume1')
+    #
+    # @example Assert that a +mount+ was disableed with predicate matchers
+    #   expect(chef_run).to disable_mount('/mnt/volume1').with_pass(4)
+    #
+    # @example Assert that a +mount+ was disableed with attributes
+    #   expect(chef_run).to disable_mount('/mnt/volume1').with(pass: 4)
+    #
+    # @example Assert that a +mount+ was disableed using a regex
+    #   expect(chef_run).to disable_mount('/mnt/volume1').with(pass: /\d+/)
+    #
+    # @example Assert that a +mount+ was _not_ disableed
+    #   expect(chef_run).to_not disable_mount('/mnt/volume1')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def disable_mount(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mount, :disable, resource_name)
+    end
+
+    #
+    # Assert that a +mount+ resource exists in the Chef run with the
+    # action +:enable+. Given a Chef Recipe that enables "/mnt/volume1" as a
+    # +mount+:
+    #
+    #     mount '/mnt/volume1' do
+    #       action :enable
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mount+ resource with ChefSpec.
+    #
+    # @example Assert that a +mount+ was enabled
+    #   expect(chef_run).to enable_mount('/mnt/volume1')
+    #
+    # @example Assert that a +mount+ was enabled with predicate matchers
+    #   expect(chef_run).to enable_mount('/mnt/volume1').with_pass(4)
+    #
+    # @example Assert that a +mount+ was enabled with attributes
+    #   expect(chef_run).to enable_mount('/mnt/volume1').with(pass: 4)
+    #
+    # @example Assert that a +mount+ was enabled using a regex
+    #   expect(chef_run).to enable_mount('/mnt/volume1').with(pass: /\d+/)
+    #
+    # @example Assert that a +mount+ was _not_ enabled
+    #   expect(chef_run).to_not enable_mount('/mnt/volume1')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def enable_mount(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mount, :enable, resource_name)
+    end
+
+    #
+    # Assert that a +mount+ resource exists in the Chef run with the
+    # action +:mount+. Given a Chef Recipe that mounts "/mnt/volume1" as a
+    # +mount+:
+    #
+    #     mount '/mnt/volume1' do
+    #       action :mount
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mount+ resource with ChefSpec.
+    #
+    # @example Assert that a +mount+ was mounted
+    #   expect(chef_run).to mount_mount('/mnt/volume1')
+    #
+    # @example Assert that a +mount+ was mounted with predicate matchers
+    #   expect(chef_run).to mount_mount('/mnt/volume1').with_pass(4)
+    #
+    # @example Assert that a +mount+ was mounted with attributes
+    #   expect(chef_run).to mount_mount('/mnt/volume1').with(pass: 4)
+    #
+    # @example Assert that a +mount+ was mounted using a regex
+    #   expect(chef_run).to mount_mount('/mnt/volume1').with(pass: /\d+/)
+    #
+    # @example Assert that a +mount+ was _not_ mounted
+    #   expect(chef_run).to_not mount_mount('/mnt/volume1')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def mount_mount(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mount, :mount, resource_name)
+    end
+
+    #
+    # Assert that a +mount+ resource exists in the Chef run with the
+    # action +:remount+. Given a Chef Recipe that remounts "/mnt/volume1" as a
+    # +mount+:
+    #
+    #     mount '/mnt/volume1' do
+    #       action :remount
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mount+ resource with ChefSpec.
+    #
+    # @example Assert that a +mount+ was remounted
+    #   expect(chef_run).to remount_mount('/mnt/volume1')
+    #
+    # @example Assert that a +mount+ was remounted with predicate matchers
+    #   expect(chef_run).to remount_mount('/mnt/volume1').with_pass(4)
+    #
+    # @example Assert that a +mount+ was remounted with attributes
+    #   expect(chef_run).to remount_mount('/mnt/volume1').with(pass: 4)
+    #
+    # @example Assert that a +mount+ was remounted using a regex
+    #   expect(chef_run).to remount_mount('/mnt/volume1').with(pass: /\d+/)
+    #
+    # @example Assert that a +mount+ was _not_ remounted
+    #   expect(chef_run).to_not remount_mount('/mnt/volume1')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def remount_mount(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mount, :remount, resource_name)
+    end
+
+    #
+    # Assert that a +mount+ resource exists in the Chef run with the
+    # action +:umount+. Given a Chef Recipe that umounts "/mnt/volume1" as a
+    # +mount+:
+    #
+    #     mount '/mnt/volume1' do
+    #       action :umount
+    #     end
+    #
+    # The Examples section demonstrates the different ways to test a
+    # +mount+ resource with ChefSpec.
+    #
+    # @example Assert that a +mount+ was umounted
+    #   expect(chef_run).to umount_mount('/mnt/volume1')
+    #
+    # @example Assert that a +mount+ was umounted with predicate matchers
+    #   expect(chef_run).to umount_mount('/mnt/volume1').with_pass(4)
+    #
+    # @example Assert that a +mount+ was umounted with attributes
+    #   expect(chef_run).to umount_mount('/mnt/volume1').with(pass: 4)
+    #
+    # @example Assert that a +mount+ was umounted using a regex
+    #   expect(chef_run).to umount_mount('/mnt/volume1').with(pass: /\d+/)
+    #
+    # @example Assert that a +mount+ was _not_ umounted
+    #   expect(chef_run).to_not umount_mount('/mnt/volume1')
+    #
+    #
+    # @param [String, Regex] resource_name
+    #   the name of the resource to match
+    #
+    # @return [ChefSpec::Matchers::ResourceMatcher]
+    #
+    def umount_mount(resource_name)
+      ChefSpec::Matchers::ResourceMatcher.new(:mount, :umount, resource_name)
+    end
+
+  end
+end