puppet 0.24.6 → 0.24.7

data/spec/unit/provider/mount/parsed.rb

@@ -0,0 +1,185 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-12.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppettest/support/utils'
+require 'puppettest/fileparsing'
+
+module ParsedMountTesting
+    include PuppetTest::Support::Utils
+    include PuppetTest::FileParsing
+
+    def fake_fstab
+        os = Facter['operatingsystem']
+        if os == "Solaris"
+            name = "solaris.fstab"
+        elsif os == "FreeBSD"
+            name = "freebsd.fstab"
+        else
+            # Catchall for other fstabs
+            name = "linux.fstab"
+        end
+        oldpath = @provider_class.default_target
+        return fakefile(File::join("data/types/mount", name))
+    end
+
+    def mkmountargs
+        mount = nil
+
+        if defined? @pcount
+            @pcount += 1
+        else
+            @pcount = 1
+        end
+        args = {
+            :name => "/fspuppet%s" % @pcount,
+            :device => "/dev/dsk%s" % @pcount,
+        }
+
+        @provider_class.fields(:parsed).each do |field|
+            unless args.include? field
+                args[field] = "fake%s%s" % [field, @pcount]
+            end
+        end
+
+        return args
+    end
+
+    def mkmount
+        hash = mkmountargs()
+        #hash[:provider] = @provider_class.name
+
+        fakeresource = stub :type => :mount, :name => hash[:name]
+        fakeresource.stubs(:[]).with(:name).returns(hash[:name])
+        fakeresource.stubs(:should).with(:target).returns(nil)
+
+        mount = @provider_class.new(fakeresource)
+        hash[:record_type] = :parsed
+        hash[:ensure] = :present
+        mount.property_hash = hash
+
+        return mount
+    end
+
+    # Here we just create a fake host type that answers to all of the methods
+    # but does not modify our actual system.
+    def mkfaketype
+        @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+    end
+end
+
+provider_class = Puppet::Type.type(:mount).provider(:parsed)
+
+describe provider_class do
+    before :each do
+        @mount_class = Puppet.type(:mount)
+        @provider_class = @mount_class.provider(:parsed)
+    end
+
+
+    describe provider_class do
+        include ParsedMountTesting
+
+        it "should be able to parse all of the example mount tabs" do
+            tab = fake_fstab
+            @provider = @provider_class
+
+            # LAK:FIXME Again, a relatively bad test, but I don't know how to rspec-ify this.
+            # I suppose this is more of an integration test?  I dunno.
+            fakedataparse(tab) do
+                # Now just make we've got some mounts we know will be there
+                hashes = @provider_class.target_records(tab).find_all { |i| i.is_a? Hash }
+                (hashes.length > 0).should be_true
+                root = hashes.find { |i| i[:name] == "/" }
+
+                proc { @provider_class.to_file(hashes) }.should_not raise_error
+            end
+        end
+
+        # LAK:FIXME I can't mock Facter because this test happens at parse-time.
+        it "should default to /etc/vfstab on Solaris and /etc/fstab everywhere else" do
+            should = case Facter.value(:operatingsystem)
+                when "Solaris": "/etc/vfstab"
+                else
+                    "/etc/fstab"
+                end
+            Puppet::Type.type(:mount).provider(:parsed).default_target.should == should
+        end
+    end
+
+    describe provider_class, " when mounting an absent filesystem" do
+        include ParsedMountTesting
+
+        # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
+        it "should flush the fstab to disk" do
+            mount = mkmount
+
+            # Mark the mount as absent
+            mount.property_hash[:ensure] = :absent
+
+            mount.stubs(:mountcmd) # just so we don't actually try to mount anything
+
+            mount.expects(:flush)
+            mount.mount
+        end
+    end
+
+    describe provider_class, " when modifying the filesystem tab" do
+        include ParsedMountTesting
+        before do
+            # Never write to disk, only to RAM.
+            @provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
+
+            @mount = mkmount
+            @target = @provider_class.default_target
+        end
+
+        it "should write the mount to disk when :flush is called" do
+            @mount.flush
+
+            text = @provider_class.target_object(@provider_class.default_target).read
+            text.should == @mount.class.to_line(@mount.property_hash) + "\n"
+        end
+    end
+
+    describe provider_class, " when parsing information about the root filesystem" do
+        confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
+        include ParsedMountTesting
+
+        before do
+            @mount = @mount_class.create :name => "/"
+            @provider = @mount.provider
+        end
+
+        it "should have a filesystem tab" do
+            FileTest.should be_exist(@provider_class.default_target)
+        end
+
+        it "should find the root filesystem" do
+            @provider_class.prefetch("/" => @mount)
+            @mount.provider.property_hash[:ensure].should == :present
+        end
+
+        it "should determine that the root fs is mounted" do
+            @provider_class.prefetch("/" => @mount)
+            @mount.provider.should be_mounted
+        end
+
+        after do
+            Puppet::Type.allclear
+        end
+    end
+
+    describe provider_class, " when mounting and unmounting" do
+        include ParsedMountTesting
+
+        it "should call the 'mount' command to mount the filesystem"
+
+        it "should call the 'unmount' command to unmount the filesystem"
+
+        it "should specify the filesystem when remounting a filesystem"
+    end
+end

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

@@ -0,0 +1,138 @@
+#!/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(:apt)
+
+describe provider do
+    before do
+        @resource = stub 'resource', :[] => "asdf"
+        @provider = provider.new(@resource)
+
+        @fakeresult = "install ok installed asdf 1.0\n"
+    end
+
+    it "should be versionable" do
+        provider.should be_versionable
+    end
+
+    it "should use :install to update" do
+        @provider.expects(:install)
+        @provider.update
+    end
+
+    it "should use 'apt-get remove' to uninstall" do
+        @provider.expects(:aptget).with("-y", "-q", :remove, "asdf")
+
+        @provider.uninstall
+    end
+
+    it "should use 'apt-get purge' and 'dpkg purge' to purge" do
+        @provider.expects(:aptget).with("-y", "-q", :remove, "--purge", "asdf")
+        @provider.expects(:dpkg).with("--purge", "asdf")
+
+        @provider.purge
+    end
+
+    it "should use 'apt-cache policy' to determine the latest version of a package" do
+        @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:
+Installed: 1:1.0
+Candidate: 1:1.1
+Version table:
+ 1:1.0
+    650 http://ftp.osuosl.org testing/main Packages
+*** 1:1.1
+    100 /var/lib/dpkg/status"
+
+        @provider.latest.should == "1:1.1"
+    end
+
+    it "should print and error and return nil if no policy is found" do
+        @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:"
+
+        @provider.expects(:err)
+        @provider.latest.should be_nil
+    end
+
+    it "should be able to preseed" do
+        @provider.should respond_to(:run_preseed)
+    end
+
+    it "should preseed with the provided responsefile when preseeding is called for" do
+        @resource.expects(:[]).with(:responsefile).returns "/my/file"
+        FileTest.expects(:exist?).with("/my/file").returns true
+
+        @provider.expects(:info)
+        @provider.expects(:preseed).with("/my/file")
+
+        @provider.run_preseed
+    end
+
+    it "should not preseed if no responsefile is provided" do
+        @resource.expects(:[]).with(:responsefile).returns nil
+
+        @provider.expects(:info)
+        @provider.expects(:preseed).never
+
+        @provider.run_preseed
+    end
+
+    it "should fail if a cdrom is listed in the sources list and :allowcdrom is not specified"
+
+    describe "when installing" do
+        it "should preseed if a responsefile is provided" do
+            @resource.expects(:[]).with(:responsefile).returns "/my/file"
+            @provider.expects(:run_preseed)
+
+            @provider.stubs(:aptget)
+            @provider.install
+        end
+
+        it "should check for a cdrom" do
+            @provider.expects(:checkforcdrom)
+
+            @provider.stubs(:aptget)
+            @provider.install
+        end
+
+        it "should use 'apt-get install' with the package name if no version is asked for" do
+            @resource.expects(:[]).with(:ensure).returns :installed
+            @provider.expects(:aptget).with { |*command| command[-1] == "asdf" and command[-2] == :install }
+            
+            @provider.install
+        end
+
+        it "should specify the package version if one is asked for" do
+            @resource.expects(:[]).with(:ensure).returns "1.0"
+            @provider.expects(:aptget).with { |*command| command[-1] == "asdf=1.0" }
+            
+            @provider.install
+        end
+
+        it "should do a quiet install" do
+            @provider.expects(:aptget).with { |*command| command.include?("-q") }
+            
+            @provider.install
+        end
+
+        it "should default to 'yes' for all questions" do
+            @provider.expects(:aptget).with { |*command| command.include?("-y") }
+            
+            @provider.install
+        end
+
+        it "should keep config files if asked" do
+            @resource.expects(:[]).with(:configfiles).returns :keep
+            @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
+            
+            @provider.install
+        end
+
+        it "should replace config files if asked" do
+            @resource.expects(:[]).with(:configfiles).returns :replace
+            @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
+            
+            @provider.install
+        end
+    end
+end

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

@@ -0,0 +1,163 @@
+#!/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(:dpkg)
+
+describe provider do
+    before do
+        @resource = stub 'resource', :[] => "asdf"
+        @provider = provider.new(@resource)
+
+        @fakeresult = "install ok installed asdf 1.0\n"
+    end
+
+    it "should have documentation" do
+        provider.doc.should be_instance_of(String)
+    end
+
+    describe "when listing all instances" do
+        before do
+            provider.stubs(:command).with(:dpkgquery).returns "myquery"
+        end
+
+        it "should use dpkg-query" do
+            provider.expects(:command).with(:dpkgquery).returns "myquery"
+            provider.expects(:execpipe).with("myquery -W --showformat '${Status} ${Package} ${Version}\\n'").returns @fakeresult
+
+            provider.instances
+        end
+
+        it "should create and return an instance with each parsed line from dpkg-query" do
+            pipe = mock 'pipe'
+            pipe.expects(:each).yields @fakeresult
+            provider.expects(:execpipe).yields pipe
+
+            asdf = mock 'pkg1'
+            provider.expects(:new).with(:ensure => "1.0", :error => "ok", :desired => "install", :name => "asdf", :status => "installed", :provider => :dpkg).returns asdf
+
+            provider.instances.should == [asdf]
+        end
+
+        it "should warn on and ignore any lines it does not understand" do
+            pipe = mock 'pipe'
+            pipe.expects(:each).yields "foobar"
+            provider.expects(:execpipe).yields pipe
+
+            Puppet.expects(:warning)
+            provider.expects(:new).never
+
+            provider.instances.should == []
+        end
+    end
+
+    describe "when querying the current state" do
+        it "should use dpkg-query" do
+            @provider.expects(:dpkgquery).with("-W", "--showformat",'${Status} ${Package} ${Version}\\n', "asdf").returns @fakeresult
+
+            @provider.query
+        end
+
+        it "should consider the package purged if dpkg-query fails" do
+            @provider.expects(:dpkgquery).raises Puppet::ExecutionFailure.new("eh")
+
+            @provider.query[:ensure].should == :purged
+        end
+
+        it "should return a hash of the found status with the desired state, error state, status, name, and 'ensure'" do
+            @provider.expects(:dpkgquery).returns @fakeresult
+
+            @provider.query.should == {:ensure => "1.0", :error => "ok", :desired => "install", :name => "asdf", :status => "installed", :provider => :dpkg}
+        end
+
+        it "should consider the package absent if the dpkg-query result cannot be interpreted" do
+            @provider.expects(:dpkgquery).returns "somebaddata"
+
+            @provider.query[:ensure].should == :absent
+        end
+
+        it "should fail if an error is discovered" do
+            @provider.expects(:dpkgquery).returns @fakeresult.sub("ok", "error")
+
+            lambda { @provider.query }.should raise_error(Puppet::Error)
+        end
+
+        it "should consider the package purged if it is marked 'not-installed'" do
+            @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "not-installed")
+
+            @provider.query[:ensure].should == :purged
+        end
+
+        it "should consider the package absent if its status is neither 'installed' nor 'not-installed'" do
+            @provider.expects(:dpkgquery).returns @fakeresult.sub("installed", "foo")
+
+            @provider.query[:ensure].should == :absent
+        end
+    end
+
+    it "should be able to install" do
+        @provider.should respond_to(:install)
+    end
+
+    describe "when installing" do
+        before do
+            @resource.stubs(:[]).with(:source).returns "mypkg"
+        end
+
+        it "should fail to install if no source is specified in the resource" do
+            @resource.expects(:[]).with(:source).returns nil
+
+            lambda { @provider.install }.should raise_error(ArgumentError)
+        end
+
+        it "should use 'dpkg -i' to install the package" do
+            @resource.expects(:[]).with(:source).returns "mypackagefile"
+            @provider.expects(:dpkg).with { |*command| command[-1] == "mypackagefile"  and command[-2] == "-i" }
+
+            @provider.install
+        end
+
+        it "should keep old config files if told to do so" do
+            @resource.expects(:[]).with(:configfiles).returns :keep
+            @provider.expects(:dpkg).with { |*command| command[0] == "--force-confold" }
+
+            @provider.install
+        end
+
+        it "should replace old config files if told to do so" do
+            @resource.expects(:[]).with(:configfiles).returns :replace
+            @provider.expects(:dpkg).with { |*command| command[0] == "--force-confnew" }
+
+            @provider.install
+        end
+    end
+
+    it "should use :install to update" do
+        @provider.expects(:install)
+        @provider.update
+    end
+
+    describe "when determining latest available version" do
+        it "should return the version found by dpkg-deb" do
+            @resource.expects(:[]).with(:source).returns "myfile"
+            @provider.expects(:dpkg_deb).with { |*command| command[-1] == "myfile" }.returns "asdf\t1.0"
+            @provider.latest.should == "1.0"
+        end
+
+        it "should warn if the package file contains a different package" do
+            @provider.expects(:dpkg_deb).returns("foo\tversion")
+            @provider.expects(:warning)
+            @provider.latest
+        end
+    end
+
+    it "should use 'dpkg -r' to uninstall" do
+        @provider.expects(:dpkg).with("-r", "asdf")
+        @provider.uninstall
+    end
+
+    it "should use 'dpkg --purge' to purge" do
+        @provider.expects(:dpkg).with("--purge", "asdf")
+        @provider.purge
+    end
+end