puppet 0.25.5 → 2.6.0

data/spec/unit/provider/package/gem.rb

@@ -1,87 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:package).provider(:gem)
-
-describe provider_class do
-    it "should have an install method" do
-        @provider = provider_class.new
-        @provider.should respond_to(:install)
-    end
-
-    describe "when installing" do
-        before do
-            # Create a mock resource
-            @resource = stub 'resource'
-
-            # A catch all; no parameters set
-            @resource.stubs(:[]).returns nil
-
-            # We have to set a name, though
-            @resource.stubs(:[]).with(:name).returns "myresource"
-            @resource.stubs(:[]).with(:ensure).returns :installed
-
-            @provider = provider_class.new
-            @provider.stubs(:resource).returns @resource
-        end
-
-        it "should use the path to the gem" do
-            provider_class.stubs(:command).with(:gemcmd).returns "/my/gem"
-            @provider.expects(:execute).with { |args| args[0] == "/my/gem" }.returns ""
-            @provider.install
-        end
-
-        it "should specify that the gem is being installed" do
-            @provider.expects(:execute).with { |args| args[1] == "install" }.returns ""
-            @provider.install
-        end
-
-        it "should specify that dependencies should be included" do
-            @provider.expects(:execute).with { |args| args[2] == "--include-dependencies" }.returns ""
-            @provider.install
-        end
-
-        it "should specify the package name" do
-            @provider.expects(:execute).with { |args| args[3] == "myresource" }.returns ""
-            @provider.install
-        end
-
-        describe "when a source is specified" do
-            describe "as a normal file" do
-                it "should use the file name instead of the gem name" do
-                    @resource.stubs(:[]).with(:source).returns "/my/file"
-                    @provider.expects(:execute).with { |args| args[3] == "/my/file" }.returns ""
-                    @provider.install
-                end
-            end
-            describe "as a file url" do
-                it "should use the file name instead of the gem name" do
-                    @resource.stubs(:[]).with(:source).returns "file:///my/file"
-                    @provider.expects(:execute).with { |args| args[3] == "/my/file" }.returns ""
-                    @provider.install
-                end
-            end
-            describe "as a puppet url" do
-                it "should fail" do
-                    @resource.stubs(:[]).with(:source).returns "puppet://my/file"
-                    lambda { @provider.install }.should raise_error(Puppet::Error)
-                end
-            end
-            describe "as a non-file and non-puppet url" do
-                it "should treat the source as a gem repository" do
-                    @resource.stubs(:[]).with(:source).returns "http://host/my/file"
-                    @provider.expects(:execute).with { |args| args[3..5] == ["--source", "http://host/my/file", "myresource"] }.returns ""
-                    @provider.install
-                end
-            end
-            describe "with an invalid uri" do
-                it "should fail" do
-                    URI.expects(:parse).raises(ArgumentError)
-                    @resource.stubs(:[]).with(:source).returns "http:::::uppet:/:/my/file"
-                    lambda { @provider.install }.should raise_error(Puppet::Error)
-                end
-            end
-        end
-    end
-end

data/spec/unit/provider/package/hpux.rb

@@ -1,52 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:package).provider(:hpux)
-
-describe provider_class do
-    before(:each) do
-        # Create a mock resource
-        @resource = stub 'resource'
-
-        # A catch all; no parameters set
-        @resource.stubs(:[]).returns(nil)
-
-        # But set name and source
-        @resource.stubs(:[]).with(:name).returns "mypackage"
-        @resource.stubs(:[]).with(:source).returns "mysource"
-        @resource.stubs(:[]).with(:ensure).returns :installed
-
-        @provider = provider_class.new
-        @provider.stubs(:resource).returns @resource
-    end
-
-    it "should have an install method" do
-        @provider = provider_class.new
-        @provider.should respond_to(:install)
-    end
-
-    it "should have an uninstall method" do
-        @provider = provider_class.new
-        @provider.should respond_to(:uninstall)
-    end
-
-    it "should have a swlist method" do
-        @provider = provider_class.new
-        @provider.should respond_to(:swlist)
-    end
-
-    describe "when installing" do
-        it "should use a command-line like 'swinstall -x mount_all_filesystems=false -s SOURCE PACKAGE-NAME'" do
-            @provider.expects(:swinstall).with('-x', 'mount_all_filesystems=false', '-s', 'mysource', 'mypackage')
-            @provider.install
-        end
-    end
-
-    describe "when uninstalling" do
-        it "should use a command-line like 'swremove -x mount_all_filesystems=false PACKAGE-NAME'" do
-            @provider.expects(:swremove).with('-x', 'mount_all_filesystems=false', 'mypackage')
-            @provider.uninstall
-        end
-    end
- end

data/spec/unit/provider/package/pkgdmg.rb

@@ -1,73 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-provider = Puppet::Type.type(:package).provider(:pkgdmg)
-
-describe provider do
-    before do
-        @resource = stub 'resource', :[] => "dummypkgdmg"
-        @provider = provider.new(@resource)
-
-        @fakemountpoint = "/tmp/dmg.foo"
-        @fakehdiutilinfo = {"system-entities" => [{"mount-point" => @fakemountpoint}] }
-        @fakehdiutilplist = Plist::Emit.dump(@fakehdiutilinfo)
-
-        @hdiutilmountargs = ["mount", "-plist", "-nobrowse", "-readonly",
-                             "-noidme", "-mountrandom", "/tmp"]
-    end
-
-    it "should not be versionable" do
-        provider.versionable?.should be_false
-    end
-
-    it "should not be uninstallable" do
-        provider.uninstallable?.should be_false
-    end
-
-    describe "when installing it should fail when" do
-        it "no source is specified" do
-            @resource.stubs(:[]).with(:source).returns nil
-            lambda { @provider.install }.should raise_error(Puppet::Error)
-        end
-
-        it "no name is specified" do
-            @resource.stubs(:[]).with(:name).returns nil
-            lambda { @provider.install }.should raise_error(Puppet::Error)
-        end
-
-        it "the source does not end in .dmg" do
-            @resource.stubs(:[]).with(:source).returns "notendingindotdmg"
-            lambda { @provider.install }.should raise_error(Puppet::Error)
-        end
-
-        it "a disk image with no system entities is mounted" do
-            @provider.stubs(:[]).with(:hdiutil).returns ""
-            lambda { @provider.install }.should raise_error(Puppet::Error)
-        end
-    end
-
-    # These tests shouldn't be this messy. The pkgdmg provider needs work...
-    describe "when installing" do
-        before do
-            fh = mock 'filehandle'
-            fh.stubs(:path).yields "/tmp/foo"
-            @resource.stubs(:[]).with(:source).returns "foo.dmg"
-            File.stubs(:open).yields fh
-        end
-
-        it "should call hdiutil to mount and eject the disk image" do
-            Dir.stubs(:entries).returns []
-            @provider.class.expects(:hdiutil).with("eject", @fakemountpoint).returns 0
-            @provider.class.expects(:hdiutil).with("mount", "-plist", "-nobrowse", "-readonly", "-noidme", "-mountrandom", "/tmp", nil).returns @fakehdiutilplist
-            @provider.install
-        end
-
-        it "should call installpkg if a pkg/mpkg is found on the dmg" do
-            Dir.stubs(:entries).returns ["foo.pkg"]
-            @provider.class.stubs(:hdiutil).returns @fakehdiutilplist
-            @provider.class.expects(:installpkg).with("#{@fakemountpoint}/foo.pkg", @resource[:name], "foo.dmg").returns ""
-            @provider.install
-        end
-    end
-end

data/spec/unit/provider/parsedfile.rb

@@ -1,95 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/provider/parsedfile'
-
-# Most of the tests for this are still in test/ral/provider/parsedfile.rb.
-describe Puppet::Provider::ParsedFile do
-    before do
-        @class = Class.new(Puppet::Provider::ParsedFile)
-    end
-
-    describe "when looking up records loaded from disk" do
-        it "should return nil if no records have been loaded" do
-            @class.record?("foo").should be_nil
-        end
-    end
-
-    describe "when generating a list of instances" do
-        it "should return an instance for each record parsed from all of the registered targets" do
-            @class.expects(:targets).returns %w{/one /two}
-            @class.stubs(:skip_record?).returns false
-            one = [:uno1, :uno2]
-            two = [:dos1, :dos2]
-            @class.expects(:prefetch_target).with("/one").returns one
-            @class.expects(:prefetch_target).with("/two").returns two
-
-            results = []
-            (one + two).each do |inst|
-                results << inst.to_s + "_instance"
-                @class.expects(:new).with(inst).returns(results[-1])
-            end
-
-            @class.instances.should == results
-        end
-
-        it "should skip specified records" do
-            @class.expects(:targets).returns %w{/one}
-            @class.expects(:skip_record?).with(:uno).returns false
-            @class.expects(:skip_record?).with(:dos).returns true
-            one = [:uno, :dos]
-            @class.expects(:prefetch_target).returns one
-
-            @class.expects(:new).with(:uno).returns "eh"
-            @class.expects(:new).with(:dos).never
-
-            @class.instances
-        end
-    end
-
-    describe "when flushing a file's records to disk" do
-        before do
-            # This way we start with some @records, like we would in real life.
-            @class.stubs(:retrieve).returns []
-            @class.default_target = "/foo/bar"
-            @class.initvars
-            @class.prefetch
-
-            @filetype = Puppet::Util::FileType.filetype(:flat).new("/my/file")
-            Puppet::Util::FileType.filetype(:flat).stubs(:new).with("/my/file").returns @filetype
-
-            @filetype.stubs(:write)
-        end
-
-        it "should back up the file being written if the filetype can be backed up" do
-            @filetype.expects(:backup)
-
-            @class.flush_target("/my/file")
-        end
-
-        it "should not try to back up the file if the filetype cannot be backed up" do
-            @filetype = Puppet::Util::FileType.filetype(:ram).new("/my/file")
-            Puppet::Util::FileType.filetype(:flat).expects(:new).returns @filetype
-
-            @filetype.stubs(:write)
-
-            @class.flush_target("/my/file")
-        end
-
-        it "should not back up the file more than once between calls to 'prefetch'" do
-            @filetype.expects(:backup).once
-
-            @class.flush_target("/my/file")
-            @class.flush_target("/my/file")
-        end
-
-        it "should back the file up again once the file has been reread" do
-            @filetype.expects(:backup).times(2)
-
-            @class.flush_target("/my/file")
-            @class.prefetch
-            @class.flush_target("/my/file")
-        end
-    end
-end

data/spec/unit/provider/selboolean.rb

@@ -1,37 +0,0 @@
-#!/usr/bin/env ruby
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-provider_class = Puppet::Type.type(:selboolean).provider(:getsetsebool)
-
-describe provider_class do
-    before :each do
-        @resource = stub("resource", :name => "foo")
-        @resource.stubs(:[]).returns "foo"
-        @provider = provider_class.new(@resource)
-    end
-
-    it "should return :on when getsebool returns on" do
-        @provider.expects(:getsebool).with("foo").returns "foo --> on\n"
-        @provider.value.should == :on
-    end
-
-    it "should return :off when getsebool returns on" do
-        @provider.expects(:getsebool).with("foo").returns "foo --> off\n"
-        @provider.value.should == :off
-    end
-
-    it "should call execpipe when updating boolean setting" do
-        @provider.expects(:command).with(:setsebool).returns "/usr/sbin/setsebool"
-        @provider.expects(:execpipe).with("/usr/sbin/setsebool  foo off")
-        @provider.value = :off
-    end
-
-    it "should call execpipe with -P when updating persistent boolean setting" do
-        @resource.stubs(:[]).with(:persistent).returns :true
-        @provider.expects(:command).with(:setsebool).returns "/usr/sbin/setsebool"
-        @provider.expects(:execpipe).with("/usr/sbin/setsebool -P foo off")
-        @provider.value = :off
-    end
-
-end

data/spec/unit/provider/selmodule.rb

@@ -1,66 +0,0 @@
-#!/usr/bin/env ruby
-
-# Note: This unit test depends on having a sample SELinux policy file
-# in the same directory as this test called selmodule-example.pp
-# with version 1.5.0.  The provided selmodule-example.pp is the first
-# 256 bytes taken from /usr/share/selinux/targeted/nagios.pp on Fedora 9
-
-Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
-
-provider_class = Puppet::Type.type(:selmodule).provider(:semodule)
-
-describe provider_class do
-    before :each do
-        @resource = stub("resource", :name => "foo")
-        @resource.stubs(:[]).returns "foo"
-        @provider = provider_class.new(@resource)
-    end
-
-    describe "exists? method" do
-        it "should find a module if it is already loaded" do
-            @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-            @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields ["bar\t1.2.3\n", "foo\t4.4.4\n", "bang\t1.0.0\n"]
-            @provider.exists?.should == :true
-        end
-
-        it "should return nil if not loaded" do
-            @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-            @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields ["bar\t1.2.3\n", "bang\t1.0.0\n"]
-            @provider.exists?.should be_nil
-        end
-
-        it "should return nil if no modules are loaded" do
-            @provider.expects(:command).with(:semodule).returns "/usr/sbin/semodule"
-            @provider.expects(:execpipe).with("/usr/sbin/semodule --list").yields []
-            @provider.exists?.should be_nil
-        end
-    end
-
-    describe "selmodversion_file" do
-        it "should return 1.5.0 for the example policy file" do
-            @provider.expects(:selmod_name_to_filename).returns "#{File.dirname(__FILE__)}/selmodule-example.pp"
-            @provider.selmodversion_file.should == "1.5.0"
-        end
-    end
-
-    describe "syncversion" do
-        it "should return :true if loaded and file modules are in sync" do
-            @provider.expects(:selmodversion_loaded).returns "1.5.0"
-            @provider.expects(:selmodversion_file).returns "1.5.0"
-            @provider.syncversion.should == :true
-        end
-
-        it "should return :false if loaded and file modules are not in sync" do
-            @provider.expects(:selmodversion_loaded).returns "1.4.0"
-            @provider.expects(:selmodversion_file).returns "1.5.0"
-            @provider.syncversion.should == :false
-        end
-
-        it "should return before checking file version if no loaded policy" do
-            @provider.expects(:selmodversion_loaded).returns nil
-            @provider.syncversion.should == :false
-        end
-
-     end
-
-end

data/spec/unit/provider/service/daemontools.rb

@@ -1,166 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Unit testing for the Daemontools service Provider
-#
-# author Brice Figureau
-#
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:service).provider(:daemontools)
-
-describe provider_class do
-
-    before(:each) do
-        # Create a mock resource
-        @resource = stub 'resource'
-
-        @provider = provider_class.new
-        @servicedir = "/etc/service"
-        @provider.servicedir=@servicedir
-        @daemondir = "/var/lib/service"
-        @provider.class.defpath=@daemondir
-
-        # A catch all; no parameters set
-        @resource.stubs(:[]).returns(nil)
-
-        # But set name, source and path (because we won't run
-        # the thing that will fetch the resource path from the provider)
-        @resource.stubs(:[]).with(:name).returns "myservice"
-        @resource.stubs(:[]).with(:ensure).returns :enabled
-        @resource.stubs(:[]).with(:path).returns @daemondir
-        @resource.stubs(:ref).returns "Service[myservice]"
-
-        @provider.resource = @resource
-
-        @provider.stubs(:command).with(:svc).returns "svc"
-        @provider.stubs(:command).with(:svstat).returns "svstat"
-
-        @provider.stubs(:svc)
-        @provider.stubs(:svstat)
-    end
-
-    it "should have a restart method" do
-        @provider.should respond_to(:restart)
-    end
-
-    it "should have a start method" do
-        @provider.should respond_to(:start)
-    end
-
-    it "should have a stop method" do
-        @provider.should respond_to(:stop)
-    end
-
-    it "should have an enabled? method" do
-        @provider.should respond_to(:enabled?)
-    end
-
-    it "should have an enable method" do
-        @provider.should respond_to(:enable)
-    end
-
-    it "should have a disable method" do
-        @provider.should respond_to(:disable)
-    end
-
-    describe "when starting" do
-        it "should use 'svc' to start the service" do
-            @provider.stubs(:enabled?).returns :true
-            @provider.expects(:svc).with("-u", "/etc/service/myservice")
-
-            @provider.start
-        end
-
-        it "should enable the service if it is not enabled" do
-            @provider.stubs(:svc)
-
-            @provider.expects(:enabled?).returns :false
-            @provider.expects(:enable)
-
-            @provider.start
-        end
-    end
-
-    describe "when stopping" do
-        it "should use 'svc' to stop the service" do
-            @provider.stubs(:disable)
-            @provider.expects(:svc).with("-d", "/etc/service/myservice")
-
-            @provider.stop
-        end
-    end
-
-    describe "when restarting" do
-        it "should use 'svc' to restart the service" do
-            @provider.expects(:svc).with("-t", "/etc/service/myservice")
-
-            @provider.restart
-        end
-    end
-
-    describe "when enabling" do
-        it "should create a symlink between daemon dir and service dir" do
-            FileTest.stubs(:symlink?).returns(false)
-            File.expects(:symlink).with(File.join(@daemondir,"myservice"), File.join(@servicedir,"myservice")).returns(0)
-            @provider.enable
-        end
-    end
-
-    describe "when disabling" do
-        it "should remove the symlink between daemon dir and service dir" do
-            FileTest.stubs(:directory?).returns(false)
-            FileTest.stubs(:symlink?).returns(true)
-            File.expects(:unlink).with(File.join(@servicedir,"myservice"))
-            @provider.stubs(:texecute).returns("")
-            @provider.disable
-        end
-
-        it "should stop the service" do
-            FileTest.stubs(:directory?).returns(false)
-            FileTest.stubs(:symlink?).returns(true)
-            File.stubs(:unlink)
-            @provider.expects(:stop)
-            @provider.disable
-        end
-    end
-
-    describe "when checking if the service is enabled?" do
-        it "should return true if it is running" do
-            @provider.stubs(:status).returns(:running)
-
-            @provider.enabled?.should == :true
-        end
-
-        [true, false].each do |t|
-            it "should return #{t} if the symlink exists" do
-                @provider.stubs(:status).returns(:stopped)
-                FileTest.stubs(:symlink?).returns(t)
-
-                @provider.enabled?.should == "#{t}".to_sym
-            end
-        end
-    end
-
-    describe "when checking status" do
-        it "should call the external command 'svstat /etc/service/myservice'" do
-            @provider.expects(:svstat).with(File.join(@servicedir,"myservice"))
-            @provider.status
-        end
-    end
-
-    describe "when checking status" do
-        it "and svstat fails, properly raise a Puppet::Error" do
-            @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).raises(Puppet::ExecutionFailure, "failure")
-            lambda { @provider.status }.should raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: failure')
-        end
-        it "and svstat returns up, then return :running" do
-            @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).returns("/etc/service/myservice: up (pid 454) 954326 seconds")
-            @provider.status.should == :running
-        end
-        it "and svstat returns not running, then return :stopped" do
-            @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).returns("/etc/service/myservice: supervise not running")
-            @provider.status.should  == :stopped
-        end
-    end
-
- end