wright 0.0.1 → 0.1.0

data/spec/resource/directory_spec.rb

@@ -0,0 +1,187 @@
+require_relative '../spec_helper'
+
+require 'wright/resource/directory'
+require 'wright/provider/directory'
+require 'fileutils'
+
+describe Wright::Resource::Directory do
+  before(:each) { @dirname = 'foo' }
+
+  after(:each) { FakeFS::FileSystem.clear }
+
+  describe '#create' do
+    it 'should create directories' do
+      FakeFS do
+        dir = Wright::Resource::Directory.new(@dirname)
+        dir.create
+        assert File.directory?(@dirname)
+        Wright::Util::File.file_mode(@dirname).must_equal ~::File.umask & 0777
+        Wright::Util::File.file_owner(@dirname).must_equal Process.uid
+        Wright::Util::File.file_group(@dirname).must_equal Process.gid
+      end
+    end
+
+    it 'should create directories with the given permissions' do
+      FakeFS do
+        dir = Wright::Resource::Directory.new(@dirname)
+        dir.mode = '644'
+        dir.owner = 23
+        dir.group = 42
+        dir.create
+        assert File.directory?(@dirname)
+        Wright::Util::File.file_mode(@dirname).must_equal 0644
+        Wright::Util::File.file_owner(@dirname).must_equal 23
+        Wright::Util::File.file_group(@dirname).must_equal 42
+      end
+    end
+
+    it 'should create directories recursively' do
+      FakeFS do
+        dirname = File.join(@dirname, @dirname, @dirname)
+        dir = Wright::Resource::Directory.new(dirname)
+        dir.create
+        assert File.directory?(dirname)
+      end
+    end
+
+    it 'should update existing directories' do
+      FakeFS do
+        FileUtils.mkdir_p(@dirname)
+        FileUtils.chmod(0600, @dirname)
+        FileUtils.chown(0, 0, @dirname)
+        dir = Wright::Resource::Directory.new(@dirname)
+        dir.mode = '644'
+        dir.owner = 23
+        dir.group = 42
+        dir.create
+        assert File.directory?(@dirname)
+        Wright::Util::File.file_mode(@dirname).must_equal 0644
+        Wright::Util::File.file_owner(@dirname).must_equal 23
+        Wright::Util::File.file_group(@dirname).must_equal 42
+      end
+    end
+
+    it 'should update the access mode for existing directories' do
+      FakeFS do
+        FileUtils.mkdir_p(@dirname)
+        FileUtils.chmod(0600, @dirname)
+        dir = Wright::Resource::Directory.new(@dirname)
+        dir.mode = '644'
+        dir.create
+        assert File.directory?(@dirname)
+        Wright::Util::File.file_mode(@dirname).must_equal 0644
+      end
+    end
+
+    it 'should not change up-to-date directories' do
+      FakeFS do
+        FileUtils.mkdir_p(@dirname)
+        mode = Wright::Util::File.file_mode(@dirname)
+        owner = Wright::Util::File.file_owner(@dirname)
+        group = Wright::Util::File.file_group(@dirname)
+        Wright::Resource::Directory.new(@dirname).create
+        Wright::Util::File.file_mode(@dirname).must_equal(mode)
+        Wright::Util::File.file_owner(@dirname).must_equal(owner)
+        Wright::Util::File.file_group(@dirname).must_equal(group)
+      end
+    end
+
+    it 'should support owner:group notation' do
+      FakeFS do
+        FileUtils.mkdir_p(@dirname)
+        FileUtils.chown(23, 45, @dirname)
+        owner = Etc.getpwuid(Process.uid).name
+        group = Etc.getgrgid(Process.gid).name
+        dir = Wright::Resource::Directory.new(@dirname)
+        dir.owner = "#{owner}:#{group}"
+        dir.create
+        Wright::Util::File.file_owner(@dirname).must_equal Process.uid
+        Wright::Util::File.file_group(@dirname).must_equal Process.gid
+      end
+    end
+
+    it 'should raise an exception when setting an invalid owner or group' do
+      dir = Wright::Resource::Directory.new(@dirname)
+      user = 'this_user_doesnt_exist'
+      group = 'this_group_doesnt_exist'
+
+      FakeFS do
+        lambda do
+          dir.owner = user
+          dir.create
+        end.must_raise ArgumentError
+        Dir.exist?(@dirname).must_equal false
+
+        lambda do
+          dir.group = group
+          dir.create
+        end.must_raise ArgumentError
+        Dir.exist?(@dirname).must_equal false
+
+        lambda do
+          dir.owner = "#{user}:#{group}"
+          dir.create
+        end.must_raise ArgumentError
+        Dir.exist?(@dirname).must_equal false
+      end
+    end
+
+    it 'should raise an exception if there is a regular file at path' do
+      FakeFS do
+        FileUtils.touch(@dirname)
+        dir = Wright::Resource::Directory.new(@dirname)
+        -> { dir.create }.must_raise Errno::EEXIST
+      end
+    end
+
+    it 'should expand paths' do
+      FakeFS do
+        dirname = '~/foobar'
+        dir = Wright::Resource::Directory.new(dirname)
+        FileUtils.mkdir_p(File.expand_path('~'))
+        dir.create
+        Dir.exist?(File.expand_path(dirname)).must_equal true
+      end
+    end
+  end
+
+  describe '#remove' do
+    it 'should remove directories' do
+      FakeFS do
+        FileUtils.mkdir_p(@dirname)
+        dir = Wright::Resource::Directory.new(@dirname)
+        dir.remove
+        assert !File.exist?(@dirname)
+      end
+    end
+
+    it 'should not remove non-empty directories' do
+      FakeFS do
+        FileUtils.mkdir_p(@dirname)
+        FileUtils.touch(File.join(@dirname, 'somefile'))
+        dir = Wright::Resource::Directory.new(@dirname)
+        -> { dir.remove }.must_raise Errno::ENOTEMPTY
+        assert File.directory?(@dirname)
+      end
+    end
+
+    it 'should not remove regular files' do
+      FakeFS do
+        FileUtils.touch(@dirname)
+        dir = Wright::Resource::Directory.new(@dirname)
+        -> { dir.remove }.must_raise RuntimeError
+        assert File.exist?(@dirname)
+      end
+    end
+
+    it 'should expand paths' do
+      FakeFS do
+        dirname = '~/foobar'
+        dir = Wright::Resource::Directory.new(dirname)
+        FileUtils.mkdir_p(File.expand_path(dirname))
+        dir.remove
+        Dir.exist?(File.expand_path(dirname)).must_equal false
+      end
+    end
+  end
+end

data/spec/resource/file_spec.rb

@@ -0,0 +1,213 @@
+require_relative '../spec_helper'
+
+require 'wright/resource/file'
+require 'wright/provider/file'
+require 'fileutils'
+
+describe Wright::Resource::File do
+  before(:each) do
+    @filename = 'foo'
+    FakeFS { FileUtils.mkdir_p Dir.tmpdir }
+  end
+
+  after(:each) { FakeFS::FileSystem.clear }
+
+  describe '#create' do
+    it 'should create files' do
+      FakeFS do
+        file = Wright::Resource::File.new(@filename)
+        file.content = 'hello world'
+        file.create
+        assert File.file?(@filename)
+        File.read(@filename).must_equal 'hello world'
+      end
+    end
+
+    it 'should create empty files when content is not set' do
+      FakeFS do
+        file = Wright::Resource::File.new(@filename)
+        file.create
+        assert File.file?(@filename)
+        File.read(@filename).must_equal ''
+      end
+    end
+
+    it 'should create files with the correct owner, group and mode' do
+      FakeFS do
+        file = Wright::Resource::File.new(@filename)
+        file.content = 'hello world'
+        file.owner = 23
+        file.group = 42
+        file.mode = '700'
+        file.create
+        assert File.file?(@filename)
+        File.read(@filename).must_equal 'hello world'
+        Wright::Util::File.file_owner(@filename).must_equal 23
+        Wright::Util::File.file_group(@filename).must_equal 42
+      end
+    end
+
+    it 'should update existing files' do
+      FakeFS do
+        FileUtils.touch(@filename)
+        FileUtils.chmod(0600, @filename)
+        FileUtils.chown(0, 0, @filename)
+        file = Wright::Resource::File.new(@filename)
+        file.mode = '644'
+        file.owner = 23
+        file.group = 42
+        file.content = 'hello world'
+        file.create
+        File.read(@filename).must_equal 'hello world'
+        Wright::Util::File.file_mode(@filename).must_equal 0644
+        Wright::Util::File.file_owner(@filename).must_equal 23
+        Wright::Util::File.file_group(@filename).must_equal 42
+      end
+    end
+
+    it 'should not overwrite existing files when content is nil' do
+      FakeFS do
+        File.write(@filename, 'old content')
+        File.chmod(0600, @filename)
+        file = Wright::Resource::File.new(@filename)
+        file.mode = '644'
+        file.create
+        File.read(@filename).must_equal 'old content'
+        Wright::Util::File.file_mode(@filename).must_equal 0644
+      end
+    end
+
+    it 'should not change up-to-date files' do
+      FakeFS do
+        File.write(@filename, 'hello world')
+        FileUtils.chmod(0600, @filename)
+        FileUtils.chown(23, 42, @filename)
+        file = Wright::Resource::File.new(@filename)
+        file.mode = '600'
+        file.owner = 23
+        file.group = 42
+        file.content = 'hello world'
+        file.create
+        File.read(@filename).must_equal 'hello world'
+        Wright::Util::File.file_mode(@filename).must_equal 0600
+        Wright::Util::File.file_owner(@filename).must_equal 23
+        Wright::Util::File.file_group(@filename).must_equal 42
+      end
+    end
+
+    it 'should throw an exception when the target is a directory' do
+      FakeFS do
+        FileUtils.mkdir_p(@filename)
+        file = Wright::Resource::File.new(@filename)
+        -> { file.create }.must_raise Errno::EISDIR
+        assert File.directory?(@filename)
+      end
+    end
+
+    it 'should support owner:group notation' do
+      FakeFS do
+        FileUtils.touch(@filename)
+        FileUtils.chown(23, 45, @filename)
+        owner = Etc.getpwuid(Process.uid).name
+        group = Etc.getgrgid(Process.gid).name
+        file = Wright::Resource::File.new(@filename)
+        file.owner = "#{owner}:#{group}"
+        file.create
+        Wright::Util::File.file_owner(@filename).must_equal Process.uid
+        Wright::Util::File.file_group(@filename).must_equal Process.gid
+      end
+    end
+
+    it 'should raise an exception when setting invalid an owner/group' do
+      file = Wright::Resource::File.new(@filename)
+      user = 'this_user_doesnt_exist'
+      group = 'this_group_doesnt_exist'
+
+      FakeFS do
+        lambda do
+          file.owner = user
+          file.create
+        end.must_raise ArgumentError
+        File.exist?(@filename).must_equal false
+
+        file.owner = nil
+        lambda do
+          file.group = group
+          file.create
+        end.must_raise ArgumentError
+        File.exist?(@filename).must_equal false
+
+        file.group = nil
+        lambda do
+          file.owner = "#{user}:#{group}"
+          file.create
+        end.must_raise ArgumentError
+        File.exist?(@filename).must_equal false
+      end
+    end
+
+    it 'should raise an exception if there is a directory at path' do
+      FakeFS do
+        FileUtils.mkdir(@filename)
+        file = Wright::Resource::File.new(@filename)
+        -> { file.create }.must_raise Errno::EISDIR
+      end
+    end
+
+    it 'should expand paths' do
+      FakeFS do
+        filename = '~/foobar'
+        expanded_path = File.expand_path(filename)
+        file = Wright::Resource::File.new(filename)
+        FileUtils.mkdir_p(File.expand_path('~'))
+        file.mode = '0765'
+        file.create
+        File.exist?(expanded_path).must_equal true
+        Wright::Util::File.file_mode(expanded_path).must_equal 0765
+      end
+    end
+  end
+
+  describe '#remove' do
+    it 'should remove files' do
+      FakeFS do
+        FileUtils.touch(@filename)
+        file = Wright::Resource::File.new(@filename)
+        file.remove
+        assert !File.exist?(@filename)
+      end
+    end
+
+    it 'should not remove directories' do
+      FakeFS do
+        FileUtils.mkdir_p(@filename)
+        file = Wright::Resource::File.new(@filename)
+        -> { file.remove }.must_raise Errno::EISDIR
+        assert File.directory?(@filename)
+      end
+    end
+
+    it 'should remove symlinks' do
+      FakeFS do
+        FileUtils.touch('target_file')
+        FileUtils.ln_s('target_file', @filename)
+        file = Wright::Resource::File.new(@filename)
+        assert File.symlink?(@filename)
+        file.remove
+        assert !File.symlink?(@filename)
+        assert File.exist?('target_file')
+      end
+    end
+
+    it 'should expand paths' do
+      FakeFS do
+        filename = '~/foobar'
+        file = Wright::Resource::File.new(filename)
+        FileUtils.mkdir_p(File.expand_path('~'))
+        FileUtils.touch(File.expand_path(filename))
+        file.remove
+        File.exist?(File.expand_path(filename)).must_equal false
+      end
+    end
+  end
+end

data/spec/resource/symlink_spec.rb

@@ -0,0 +1,117 @@
+require_relative '../spec_helper'
+
+require 'wright/resource/symlink'
+require 'wright/provider/symlink'
+require 'fileutils'
+
+describe Wright::Resource::Symlink do
+  before(:each) do
+    @target = 'foo'
+    @link_name = 'bar'
+  end
+
+  after(:each) { FakeFS::FileSystem.clear }
+
+  def link_resource(target, link_name)
+    link = Wright::Resource::Symlink.new(link_name)
+    link.to = target
+    link
+  end
+
+  describe '#create' do
+    it 'should create symlinks' do
+      FakeFS do
+        link = link_resource(@target, @link_name)
+        link.create
+        File.symlink?(@link_name).must_equal true
+        File.readlink(@link_name).must_equal @target
+      end
+    end
+
+    it 'should update symlinks to files' do
+      FakeFS do
+        link = link_resource(@target, @link_name)
+        FileUtils.ln_sf('oldtarget', @link_name)
+        link.create
+
+        assert File.symlink?(@link_name)
+        File.readlink(@link_name).must_equal @target
+      end
+    end
+
+    it 'should update symlinks to directories' do
+      FakeFS do
+        link = link_resource(@target, @link_name)
+        FileUtils.mkdir_p('somedir')
+        FileUtils.ln_s('somedir', @link_name)
+        link.create
+
+        assert File.symlink?(@link_name)
+        File.readlink(@link_name).must_equal @target
+      end
+    end
+
+    it 'should not overwrite existing files' do
+      FakeFS do
+        file_content = 'Hello world'
+        File.write(@link_name, file_content)
+        link = link_resource(@target, @link_name)
+        -> { link.create }.must_raise Errno::EEXIST
+        File.read(@link_name).must_equal file_content
+      end
+    end
+
+    it 'should expand paths' do
+      FakeFS do
+        FileUtils.mkdir_p(File.expand_path('~'))
+        link = Wright::Resource::Symlink.new('~/foo')
+        link.to = '~/bar/..'
+        link.create
+
+        File.exist?(File.expand_path('~/foo')).must_equal true
+        expected = File.join(File.expand_path('~'), 'bar/..')
+        actual = File.readlink(File.expand_path('~/foo'))
+        expected.must_equal actual
+      end
+    end
+  end
+
+  describe '#remove' do
+    it 'should remove existing symlinks' do
+      FakeFS do
+        link = Wright::Resource::Symlink.new(@link_name)
+        FileUtils.touch(@target)
+        FileUtils.ln_s(@target, @link_name)
+
+        File.exist?(@target).must_equal true
+        File.symlink?(@link_name).must_equal true
+        link.remove
+        File.exist?(@target).must_equal true
+        File.symlink?(@link_name).must_equal false
+      end
+    end
+
+    it 'should not remove existing regular files' do
+      FakeFS do
+        FileUtils.touch(@link_name)
+        link = Wright::Resource::Symlink.new(@link_name)
+        File.exist?(@link_name).must_equal true
+        -> { link.remove }.must_raise RuntimeError
+        File.exist?(@link_name).must_equal true
+      end
+    end
+
+    it 'should expand paths' do
+      FakeFS do
+        FileUtils.mkdir_p(File.expand_path('~'))
+        FileUtils.touch(File.expand_path('~/bar'))
+        FileUtils.ln_sf(File.expand_path('~/bar'),
+                        File.expand_path('~/foo'))
+        link = Wright::Resource::Symlink.new('~/foo')
+        link.remove
+        File.exist?(File.expand_path('~/foo')).must_equal false
+        File.exist?(File.expand_path('~/bar')).must_equal true
+      end
+    end
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,184 @@
+require_relative 'spec_helper'
+
+require 'wright/resource'
+require 'wright/provider'
+
+module Wright
+  # add provider attribute reader for tests
+  class Resource
+    attr_reader :provider
+  end
+end
+
+module Wright
+  class Provider
+    class Sample < Wright::Provider; end
+    class AlternateSample < Wright::Provider; end
+
+    # provider that is always updated
+    class AlwaysUpdated < Wright::Provider
+      def updated?
+        true
+      end
+    end
+
+    # provider that is never updated
+    class NeverUpdated < Wright::Provider
+      def updated?
+        false
+      end
+    end
+  end
+end
+
+class Sample < Wright::Resource; end
+
+# resource with a single method to test update notification
+class Updater < Wright::Resource
+  def do_something
+    might_update_resource {}
+  end
+end
+
+describe Wright::Resource do
+  before(:each) do
+    @config = Wright::Config.config_hash.clone
+    Wright::Config.config_hash.clear
+    @hello = 'Hello world'
+    @say_hello = -> { print @hello }
+  end
+
+  after(:each) do
+    Wright::Config.config_hash = @config
+  end
+
+  it 'should retrieve a provider for a resource' do
+    provider_class = Wright::Provider::Sample
+    Sample.new.provider.must_be_kind_of provider_class
+  end
+
+  it 'should retrieve a provider for a resource listed in the config' do
+    # instantiating the Sample resource without any config should
+    # yield the Sample provider
+    provider_class = Wright::Provider::Sample
+    Sample.new.provider.must_be_kind_of provider_class
+
+    # when the provider for Sample resources is set to
+    # AlternateSample, AlternateSample should be instantiated
+    alternate = Wright::Provider::AlternateSample
+    Wright::Config[:resources] = { sample: { provider: alternate.name } }
+    Sample.new.provider.must_be_kind_of alternate
+  end
+
+  it 'should display warnings for nonexistent providers' do
+    class NonExistent < Wright::Resource; end
+    output = "WARN: Could not find a provider for resource NonExistent\n"
+    lambda do
+      reset_logger
+      NonExistent.new
+    end.must_output(output)
+  end
+
+  it 'should run update actions on updates' do
+    provider = Wright::Provider::AlwaysUpdated
+    Wright::Config[:resources] = { updater: { provider: provider.name } }
+    resource = Updater.new
+    lambda do
+      resource.on_update = @say_hello
+      assert resource.do_something
+    end.must_output @hello
+  end
+
+  it 'should not run update actions if there were no updates' do
+    provider = Wright::Provider::NeverUpdated
+    Wright::Config[:resources] = { updater: { provider: provider.name } }
+    resource = Updater.new
+    lambda do
+      resource.on_update = @say_hello
+      assert !resource.do_something
+    end.must_be_silent
+  end
+
+  it 'should not run update actions in dry-run mode' do
+    Wright.dry_run do
+      provider = Wright::Provider::AlwaysUpdated
+      Wright::Config[:resources] = { updater: { provider: provider.name } }
+      name = :farnsworth
+      resource = Updater.new(name)
+      resource_info = "#{resource.resource_name} '#{name}'"
+      output = "INFO: Would trigger update action for #{resource_info}\n"
+      lambda do
+        reset_logger
+        resource.on_update = @say_hello
+        assert resource.do_something
+      end.must_output output
+    end
+  end
+
+  it 'should raise an ArgumentError if on_update is not callable' do
+    resource = Sample.new
+    -> { resource.on_update = "I'm a string" }.must_raise ArgumentError
+    -> { resource.on_update = -> {} }.must_be_silent
+    -> { resource.on_update = nil }.must_be_silent
+  end
+
+  it 'should run actions' do
+    # simple resource to test different actions
+    class NiSayer < Wright::Resource
+      def say
+        print 'Ni!'
+      end
+
+      def shout
+        print 'NI!'
+      end
+    end
+    Wright::Config[:resources] = { ni_sayer: { provider: 'Sample' } }
+    ni_sayer = NiSayer.new
+    lambda do
+      ni_sayer.action = :say
+      ni_sayer.run_action
+    end.must_output 'Ni!'
+    lambda do
+      ni_sayer.action = :shout
+      ni_sayer.run_action
+    end.must_output 'NI!'
+    lambda do
+      ni_sayer.action = nil
+      ni_sayer.run_action
+    end.must_be_silent
+  end
+
+  it 'should not raise exceptions if ignore_failure is enabled' do
+    module Wright
+      class Provider
+        # provider that always raises exceptions
+        class RaisesExceptions < Wright::Provider
+          def fail_train
+            fail 'Fail train!'
+          end
+        end
+      end
+    end
+
+    # resource that always raises exceptions
+    class RaisesExceptions < Wright::Resource
+      def fail_train
+        might_update_resource { @provider.fail_train }
+      end
+    end
+
+    resource = RaisesExceptions.new('fake_name')
+
+    lambda do
+      resource.ignore_failure = true
+      reset_logger
+      resource.fail_train
+    end.must_output "ERROR: raises_exceptions 'fake_name': Fail train!\n"
+
+    lambda do
+      resource.ignore_failure = false
+      resource.fail_train
+    end.must_raise(RuntimeError)
+  end
+end