minitest-chef-handler 0.3.0 → 0.4.0

data/examples/spec_examples/templates/default/foo.erb

@@ -0,0 +1,3 @@
+# Sample configuration file for test purposes.
+#
+phaser_setting=<%= @phasers %>

data/lib/minitest-chef-handler.rb

@@ -1,4 +1,11 @@
-require 'minitest/unit'
+require 'minitest-chef-handler/context'
+require 'minitest-chef-handler/resources'
+require 'minitest-chef-handler/unit'
+require 'minitest-chef-handler/spec'
+require 'minitest-chef-handler/runner'
+
+require 'minitest-chef-handler/assertions'
+require 'minitest-chef-handler/infections'
 
 module MiniTest
   module Chef
@@ -42,27 +49,5 @@ module MiniTest
         Gem::Version.new(MiniTest::Unit::VERSION) >= Gem::Version.new('2.1.0')
       end
     end
-
-    class Runner < MiniTest::Unit
-      attr_reader :run_status
-
-      def initialize(run_status)
-        @run_status = run_status
-        super()
-      end
-    end
-
-    class TestCase < MiniTest::Unit::TestCase
-      attr_reader :run_status, :node, :run_context
-
-      def run(runner)
-        if runner.respond_to?(:run_status)
-          @run_status = runner.run_status
-          @node = @run_status.node
-          @run_context = @run_status.run_context
-        end
-        super(runner)
-      end
-    end
   end
 end

data/lib/minitest-chef-handler/assertions.rb

@@ -0,0 +1,129 @@
+module MiniTest
+  module Chef
+    module Assertions
+
+      def self.resource_exists(name, options)
+        options[:description] = name unless options[:description]
+        define_method("assert_#{name}_exists") do |resource|
+          refute resource.send(options[:field]).nil?,
+            "Expected #{options[:description]} '#{resource.name}' to exist"
+          resource
+        end
+        define_method("refute_#{name}_exists") do |resource|
+          assert resource.send(options[:field]).nil?,
+            "Expected #{options[:description]} '#{resource.name}' to not exist"
+          resource
+        end
+      end
+
+      resource_exists :cron,     :field => :command, :description => 'cron entry'
+      resource_exists :group,    :field => :gid
+      resource_exists :ifconfig, :field => :device, :description => 'network interface'
+      resource_exists :link,     :field => :to
+      resource_exists :user,     :field => :uid
+
+      def assert_enabled(service)
+        assert service.enabled, "Expected service '#{service.name}' to be enabled"
+        service
+      end
+
+      def refute_enabled(service)
+        refute service.enabled, "Expected service '#{service.name}' to not be enabled"
+        service
+      end
+
+      def assert_group_includes(members, group)
+        members = [members] unless members.respond_to?(:&)
+        assert group.members & members == members, "Expected group '#{group.name}' to include members: #{members.join(', ')}"
+        group
+      end
+
+      def refute_group_includes(members, group)
+        members = [members] unless members.respond_to?(:&)
+        refute group.members & members == members, "Expected group '#{group.name}' not to include members: #{members.join(', ')}"
+        group
+      end
+
+      def assert_includes_content(file, content)
+        assert File.read(file.path).include?(content), "Expected file '#{file.path}' to include the specified content"
+        file
+      end
+
+      def refute_includes_content(file, content)
+        refute File.read(file.path).include?(content), "Expected file '#{file.path}' not to include the specified content"
+        file
+      end
+
+      def assert_installed(package)
+        refute package.version.nil?, "Expected package '#{package.name}' to be installed"
+        package
+      end
+
+      def refute_installed(package)
+        assert package.version.nil?, "Expected package '#{package.name}' to not be installed"
+        package
+      end
+
+      def assert_matches_content(file, regexp)
+        assert File.read(file.path).match(regexp), "Expected the contents of file '#{file.path}' to match the regular expression '#{regexp}'"
+        file
+      end
+
+      def refute_matches_content(file, regexp)
+        refute File.read(file.path).match(regexp), "Expected the contents of file '#{file.path}' not to match the regular expression '#{regexp}'"
+        file
+      end
+
+      def assert_modified_after(file_or_dir, time)
+        assert File.mtime(file_or_dir.path).to_i >= time.to_i, "Expected the file '#{file_or_dir.path}' to have been modified after '#{time}'"
+        file_or_dir
+      end
+
+      def refute_modified_after(file_or_dir, time)
+        refute File.mtime(file_or_dir.path) >= time, "Expected the file '#{file_or_dir.path}' not to have been modified after '#{time}'"
+        file_or_dir
+      end
+
+      def assert_mounted(mount)
+        assert mount.mounted, "Expected mount point '#{mount.name}' to be mounted"
+        mount
+      end
+
+      def refute_mounted(mount)
+        refute mount.mounted, "Expected mount point '#{mount.name}' to not be mounted"
+        mount
+      end
+
+      def assert_mount_enabled(mount)
+        assert mount.enabled, "Expected mount point '#{mount.name}' to be enabled"
+        mount
+      end
+
+      def refute_mount_enabled(mount)
+        refute mount.enabled, "Expected mount point '#{mount.name}' to not be enabled"
+        mount
+      end
+
+      def assert_path_exists(file_or_dir)
+        assert File.exists?(file_or_dir.path), "Expected path '#{file_or_dir.path}' to exist"
+        file_or_dir
+      end
+
+      def refute_path_exists(file_or_dir)
+        refute File.exists?(file_or_dir.path), "Expected path '#{file_or_dir.path}' not to exist"
+        file_or_dir
+      end
+
+      def assert_running(service)
+        assert service.running, "Expected service '#{service.name}' to be running"
+        service
+      end
+
+      def refute_running(service)
+        refute service.running, "Expected service '#{service.name}' not to be running"
+        service
+      end
+
+    end
+  end
+end

data/lib/minitest-chef-handler/context.rb

@@ -0,0 +1,16 @@
+module MiniTest
+  module Chef
+    module Context
+      attr_reader :run_status, :node, :run_context
+
+      def run(runner)
+        if runner.respond_to?(:run_status)
+          @run_status = runner.run_status
+          @node = @run_status.node
+          @run_context = @run_status.run_context
+        end
+        super(runner)
+      end
+    end
+  end
+end

data/lib/minitest-chef-handler/infections.rb

@@ -0,0 +1,37 @@
+require 'chef'
+
+module MiniTest
+  module Chef
+    module Infections extend ::Chef::Mixin::ConvertToClassName
+
+      def self.infect_resource(resource, meth, new_name)
+        clazz = ::Chef::Resource.const_get(convert_to_class_name(resource.to_s))
+        clazz.infect_an_assertion "assert_#{meth}".to_sym,
+          "must_#{new_name}".to_sym, :only_one_argument
+        clazz.infect_an_assertion "refute_#{meth}".to_sym,
+          "wont_#{new_name}".to_sym, :only_one_argument
+      end
+
+      infect_resource :cron, :cron_exists, :exist
+      infect_resource :directory, :modified_after, :be_modified_after
+      infect_resource :directory, :path_exists, :exist
+      infect_resource :file, :includes_content, :include
+      infect_resource :file, :matches_content, :match
+      infect_resource :file, :modified_after, :be_modified_after
+      infect_resource :file, :path_exists, :exist
+      infect_resource :group, :group_exists, :exist
+      infect_resource :ifconfig, :ifconfig_exists, :exist
+      infect_resource :link, :link_exists, :exist
+      infect_resource :mount, :mounted, :be_mounted
+      infect_resource :mount, :mount_enabled, :be_enabled
+      infect_resource :service, :enabled, :be_enabled
+      infect_resource :service, :running, :be_running
+      infect_resource :package, :installed, :be_installed
+      infect_resource :user, :user_exists, :exist
+
+      ::Chef::Resource::Group.infect_an_assertion :assert_group_includes, :must_include
+      ::Chef::Resource::Group.infect_an_assertion :refute_group_includes, :wont_include
+
+    end
+  end
+end

data/lib/minitest-chef-handler/resources.rb

@@ -0,0 +1,54 @@
+require 'chef'
+require 'etc'
+require 'minitest/unit'
+
+module MiniTest
+  module Chef
+    module Resources
+      include ::Chef::Mixin::ConvertToClassName
+
+      def self.register_resource(resource, *required_args)
+        define_method(resource) do |name, *options|
+          clazz = ::Chef::Resource.const_get(convert_to_class_name(resource.to_s))
+          res = clazz.new(name, run_context)
+          required_args.each do |arg|
+            res.send(arg, options.first[arg])
+          end
+          provider = ::Chef::Platform.provider_for_resource(res)
+          provider.load_current_resource
+          provider.current_resource
+        end
+      end
+
+      [:cron, :directory, :file, :group,
+       :link, :package, :service, :user].each{ |r| register_resource(r) }
+
+      register_resource(:ifconfig, :device)
+      register_resource(:mount, :device)
+
+      ::Chef::Resource.class_eval do
+        include MiniTest::Assertions
+        def with(attribute, values)
+          actual_values = resource_value(attribute, values)
+          assert_equal values, actual_values,
+            "The #{resource_name} does not have the expected #{attribute}"
+          self
+        end
+        alias :and :with
+        alias :must_have :with
+        private
+
+        def resource_value(attribute, values)
+          case attribute
+            when :mode then mode.kind_of?(Integer) ? mode.to_s(8) : mode.to_s
+            when :owner || :user then Etc.getpwuid(owner).name
+            when :group then Etc.getgrgid(group).name
+            else send(attribute)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/minitest-chef-handler/runner.rb

@@ -0,0 +1,12 @@
+module MiniTest
+  module Chef
+    class Runner < MiniTest::Unit
+      attr_reader :run_status
+
+      def initialize(run_status)
+        @run_status = run_status
+        super()
+      end
+    end
+  end
+end

data/lib/minitest-chef-handler/spec.rb

@@ -0,0 +1,19 @@
+module MiniTest
+  module Chef
+    require 'minitest/spec'
+
+    class Spec < MiniTest::Spec
+      include Assertions
+      include Context
+      include Resources
+    end
+
+    MiniTest::Spec.register_spec_type(/\Arecipe::/, MiniTest::Chef::Spec)
+  end
+end
+
+module Kernel
+  def describe_recipe(desc, additional_desc = nil, &block)
+    describe('recipe::' + desc, additional_desc, &block)
+  end
+end

data/lib/minitest-chef-handler/unit.rb

@@ -0,0 +1,11 @@
+module MiniTest
+  module Chef
+    require 'minitest/unit'
+
+    class TestCase < MiniTest::Unit::TestCase
+      include Assertions
+      include Context
+      include Resources
+    end
+  end
+end

data/minitest-chef-handler.gemspec

@@ -11,7 +11,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = "minitest-chef-handler"
   gem.require_paths = ["lib"]
-  gem.version       = '0.3.0'
+  gem.version       = '0.4.0'
 
+  gem.add_dependency('chef')
   gem.add_development_dependency('rake')
+  gem.add_development_dependency('rspec')
 end

data/spec/minitest-chef-handler/assertions_spec.rb

@@ -0,0 +1,293 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe MiniTest::Chef::Assertions do
+
+  include MiniTest::Chef::Assertions
+
+  def resource_for(hash)
+    Class.new do
+      hash.each_pair do |key,value|
+        define_method(key) { value }
+      end
+    end.new
+  end
+
+  module MiniTest::Chef::Assertions
+    class File
+      def self.read(path)
+        '# Generated by Chef'
+      end
+      def self.mtime(path)
+        Time.now.utc
+      end
+      def self.exists?(path)
+        path == '/etc/foo'
+      end
+    end
+  end
+
+  it "verifies that cron entries exist" do
+    cron = resource_for({:name => 'foo', :command => 'ls'})
+    assert_cron_exists(cron).must_equal cron
+    assert_triggered "Expected cron entry 'foo' to exist" do
+      assert_cron_exists(resource_for({:name => 'foo', :command => nil}))
+    end
+  end
+
+  it "verifies that cron entries do not exist" do
+    cron = resource_for({:name => 'foo', :command => nil})
+    refute_cron_exists(cron).must_equal cron
+    assert_triggered "Expected cron entry 'foo' to not exist" do
+      refute_cron_exists(resource_for({:name => 'foo', :command => 'ls'}))
+    end
+  end
+
+  it "verifies that groups exist" do
+    group = resource_for({:name => 'foo', :gid => 100})
+    assert_group_exists(group).must_equal group
+    assert_triggered "Expected group 'foo' to exist" do
+      assert_group_exists(resource_for({:name => 'foo', :gid => nil}))
+    end
+  end
+
+  it "verifies that groups do not exist" do
+    group = resource_for({:name => 'foo', :gid => nil})
+    refute_group_exists(group).must_equal group
+    assert_triggered "Expected group 'foo' to not exist" do
+      refute_group_exists(resource_for({:name => 'foo', :gid => 100}))
+    end
+  end
+
+  it "verifies that network interfaces exist" do
+    ifconfig = resource_for({:name => 'foo', :device => '/dev/eth0'})
+    assert_ifconfig_exists(ifconfig).must_equal ifconfig
+    assert_triggered "Expected network interface 'foo' to exist" do
+      assert_ifconfig_exists(resource_for({:name => 'foo', :device => nil}))
+    end
+  end
+
+  it "verifies that network interfaces do not exist" do
+    ifconfig = resource_for({:name => 'foo', :device => nil})
+    refute_ifconfig_exists(ifconfig).must_equal ifconfig
+    assert_triggered "Expected network interface 'foo' to not exist" do
+      refute_ifconfig_exists(resource_for({:name => 'foo', :device => '/dev/eth0'}))
+    end
+  end
+
+  it "verifies that filesystem links exist" do
+    link = resource_for({:name => 'foo', :to => 'bar'})
+    assert_link_exists(link).must_equal link
+    assert_triggered "Expected link 'foo' to exist" do
+      assert_link_exists(resource_for({:name => 'foo', :to => nil}))
+    end
+  end
+
+  it "verifies that filesystem links do not exist" do
+    link = resource_for({:name => 'foo', :to => nil})
+    refute_link_exists(link).must_equal link
+    assert_triggered "Expected link 'foo' to not exist" do
+      refute_link_exists(resource_for({:name => 'foo', :to => 'bar'}))
+    end
+  end
+
+  it "verifies that users exist" do
+    user = resource_for({:name => 'foo', :uid => 200})
+    assert_user_exists(user).must_equal user
+    assert_triggered "Expected user 'foo' to exist" do
+      assert_user_exists(resource_for({:name => 'foo', :uid => nil}))
+    end
+  end
+
+  it "verifies that users do not exist" do
+    user = resource_for({:name => 'foo', :uid => nil})
+    refute_user_exists(user).must_equal user
+    assert_triggered "Expected user 'foo' to not exist" do
+      refute_user_exists(resource_for({:name => 'foo', :uid => 200}))
+    end
+  end
+
+  it "verifies that services are enabled" do
+    service = resource_for({:name => 'bar', :enabled => true})
+    assert_enabled(service).must_equal service
+    assert_triggered "Expected service 'bar' to be enabled" do
+      assert_enabled(resource_for({:name => 'bar', :enabled => false}))
+    end
+  end
+
+  it "verifies that services are not enabled" do
+    service = resource_for({:name => 'bar', :enabled => false})
+    refute_enabled(service).must_equal service
+    assert_triggered "Expected service 'bar' to not be enabled" do
+      refute_enabled(resource_for({:name => 'bar', :enabled => true}))
+    end
+  end
+
+  it "verifies that a group contains the expected members" do
+    group = resource_for({:name => 'foo', :members => ['bar', 'baz']})
+    assert_group_includes('bar', group).must_equal group
+    assert_group_includes(['bar'], group).must_equal group
+    assert_group_includes(['bar', 'baz'], group).must_equal group
+    assert_triggered "Expected group 'foo' to include members: bar" do
+      assert_group_includes('bar',
+        resource_for({:name => 'foo', :members => ['baz']}))
+    end
+    assert_triggered "Expected group 'foo' to include members: bar, bert" do
+      assert_group_includes(['bar', 'bert'],
+        resource_for({:name => 'foo', :members => ['baz']}))
+    end
+    assert_triggered "Expected group 'foo' to include members: bar, bert" do
+      assert_group_includes(['bar', 'bert'],
+        resource_for({:name => 'foo', :members => ['bar', 'baz']}))
+    end
+  end
+
+  it "verifies that a group does not contain the expected members" do
+    group = resource_for({:name => 'foo', :members => ['bar', 'baz']})
+    refute_group_includes('fum', group).must_equal group
+    refute_group_includes(['fum'], group).must_equal group
+    refute_group_includes(['fum', 'baz'], group).must_equal group
+    assert_triggered "Expected group 'foo' not to include members: bar" do
+      refute_group_includes('bar',
+        resource_for({:name => 'foo', :members => ['bar']}))
+    end
+    assert_triggered "Expected group 'foo' not to include members: bar" do
+      refute_group_includes(['bar'],
+        resource_for({:name => 'foo', :members => ['bar', 'bert']}))
+    end
+    assert_triggered "Expected group 'foo' not to include members: bar, bert" do
+      refute_group_includes(['bar', 'bert'],
+        resource_for({:name => 'foo', :members => ['bar', 'bert']}))
+    end
+  end
+
+  it "verifies that a file includes the specified content" do
+    file = resource_for({:path => '/etc/bar'})
+    assert_includes_content(file, 'Chef').must_equal file
+    assert_triggered "Expected file '/etc/bar' to include the specified content" do
+      assert_includes_content(resource_for({:path => '/etc/bar'}), 'chef')
+    end
+  end
+
+  it "verifies that a file does not include the specified content" do
+    file = resource_for({:path => '/etc/bar'})
+    refute_includes_content(file, 'chef').must_equal file
+    assert_triggered "Expected file '/etc/bar' not to include the specified content" do
+      refute_includes_content(resource_for({:path => '/etc/bar'}), 'Chef')
+    end
+  end
+
+  it "verifies that a package is installed" do
+    package = resource_for({:name => 'bash', :version => '4.2-0ubuntu4'})
+    assert_installed(package).must_equal package
+    assert_triggered "Expected package 'bash' to be installed" do
+      assert_installed(resource_for({:name => 'bash', :version => nil}))
+    end
+  end
+
+  it "verifies that a package is not installed" do
+    package = resource_for({:name => 'bash', :version => nil})
+    refute_installed(package).must_equal package
+    assert_triggered "Expected package 'bash' to not be installed" do
+      refute_installed(resource_for({:name => 'bash', :version => '4.2-0ubuntu4'}))
+    end
+  end
+
+  it "verifies that a file matches the specified content" do
+    file = resource_for({:path => '/etc/bar'})
+    assert_matches_content(file, /Chef$/).must_equal file
+    assert_triggered "Expected the contents of file '/etc/bar' to match the regular expression '^Chef'" do
+      assert_matches_content(resource_for({:path => '/etc/bar'}), '^Chef')
+    end
+  end
+
+  it "verifies that a file does not match the specified content" do
+    file = resource_for({:path => '/etc/bar'})
+    refute_matches_content(file, /^Chef/).must_equal file
+    assert_triggered "Expected the contents of file '/etc/bar' not to match the regular expression 'Chef$'" do
+      refute_matches_content(resource_for({:path => '/etc/bar'}), 'Chef$')
+    end
+  end
+
+  it "verifies that a file was modified after the specified time" do
+    file = resource_for({:path => '/etc/bar'})
+    the_distant_future = Time.utc(Time.now.utc.year + 30)
+    assert_modified_after(file, Time.at(0).utc).must_equal file
+    assert_triggered "Expected the file '/etc/bar' to have been modified after '#{the_distant_future}'" do
+      assert_modified_after(resource_for({:path => '/etc/bar'}), the_distant_future)
+    end
+  end
+
+  it "verifies that a file was not modified after the specified time" do
+    file = resource_for({:path => '/etc/bar'})
+    the_distant_future = Time.utc(Time.now.utc.year + 30)
+    refute_modified_after(file, the_distant_future).must_equal file
+    assert_triggered "Expected the file '/etc/bar' not to have been modified after '#{Time.at(0).utc}'" do
+      refute_modified_after(resource_for({:path => '/etc/bar'}), Time.at(0).utc)
+    end
+  end
+
+  it "verifies that a mount point is mounted" do
+    mount = resource_for({:name => '/mnt/foo', :mounted => true})
+    assert_mounted(mount).must_equal mount
+    assert_triggered "Expected mount point '/mnt/foo' to be mounted" do
+      assert_mounted(resource_for({:name => '/mnt/foo', :mounted => false}))
+    end
+  end
+
+  it "verifies that a mount point is not mounted" do
+    mount = resource_for({:name => '/mnt/foo', :mounted => false})
+    refute_mounted(mount).must_equal mount
+    assert_triggered "Expected mount point '/mnt/foo' to not be mounted" do
+      refute_mounted(resource_for({:name => '/mnt/foo', :mounted => true}))
+    end
+  end
+
+  it "verifies that a mount point is enabled" do
+    mount = resource_for({:name => '/mnt/foo', :enabled => true})
+    assert_mount_enabled(mount).must_equal mount
+    assert_triggered "Expected mount point '/mnt/foo' to be enabled" do
+      assert_mount_enabled(resource_for({:name => '/mnt/foo', :enabled => false}))
+    end
+  end
+
+  it "verifies that a mount point is not enabled" do
+    mount = resource_for({:name => '/mnt/foo', :enabled => false})
+    refute_mount_enabled(mount).must_equal mount
+    assert_triggered "Expected mount point '/mnt/foo' to not be enabled" do
+      refute_mount_enabled(resource_for({:name => '/mnt/foo', :enabled => true}))
+    end
+  end
+
+  it "verifies that a file path exists" do
+    file = resource_for({:path => '/etc/foo'})
+    assert_path_exists(file).must_equal file
+    assert_triggered "Expected path '/etc/bar' to exist" do
+      assert_path_exists(resource_for({:path => '/etc/bar'}))
+    end
+  end
+
+  it "verifies that a file path does not exist" do
+    file = resource_for({:path => '/etc/bar'})
+    refute_path_exists(file).must_equal file
+    assert_triggered "Expected path '/etc/foo' not to exist" do
+      refute_path_exists(resource_for({:path => '/etc/foo'}))
+    end
+  end
+
+  it "verifies that a service is running" do
+    service = resource_for({:name => 'httpd', :running => true})
+    assert_running(service).must_equal service
+    assert_triggered "Expected service 'httpd' to be running" do
+      assert_running(resource_for({:name => 'httpd', :running => false}))
+    end
+  end
+
+  it "verifies that a service is not running" do
+    service = resource_for({:name => 'httpd', :running => false})
+    refute_running(service).must_equal service
+    assert_triggered "Expected service 'httpd' not to be running" do
+      refute_running(resource_for({:name => 'httpd', :running => true}))
+    end
+  end
+
+end