puppet 0.18.4 → 0.22.4

data/test/ral/providers/host/netinfo.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2006-11-12.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+if Puppet::Type.type(:host).provider(:netinfo).suitable?
+class TestNetinfoHostProvider < Test::Unit::TestCase
+	include PuppetTest
+	
+	def setup
+	    super
+	    @host = Puppet::Type.type(:host)
+	    @provider = @host.provider(:netinfo)
+    end
+
+	def test_list
+	    list = nil
+	    assert_nothing_raised do
+	        list = @provider.list
+        end
+        assert(list.length > 0)
+        list.each do |obj|
+            prov = obj.provider
+            assert_instance_of(@host, obj)
+            assert(prov.name, "objects do not have names")
+            assert(prov.ip, "Did not get value for device in %s" % prov.ip)
+        end
+
+        assert(list.detect { |m| m.provider.name == "localhost"}, "Could not find localhost")
+    end
+    
+    if Process.uid == 0
+    def test_simple
+        localhost = nil
+        assert_nothing_raised do
+            localhost = @host.create :name => "localhost", :check => [:ip], :provider => :netinfo
+        end
+        
+        assert_nothing_raised do
+            localhost.retrieve
+        end
+        
+        prov = localhost.provider
+        
+        assert_nothing_raised do
+            assert(prov.ip, "Did not find value for ip")
+            assert(prov.ip != :absent, "Netinfo thinks the localhost is missing")
+        end
+    end
+end
+end
+end
+
+# $Id: netinfo.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/providers/host/parsed.rb

@@ -0,0 +1,226 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
+
+require 'etc'
+require 'puppettest'
+require 'puppettest/fileparsing'
+require 'test/unit'
+
+class TestParsedHostProvider < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::FileParsing
+
+    def setup
+        super
+        @provider = Puppet.type(:host).provider(:parsed)
+
+        @oldfiletype = @provider.filetype
+    end
+
+    def teardown
+        Puppet::Util::FileType.filetype(:ram).clear
+        @provider.filetype = @oldfiletype
+        @provider.clear
+        super
+    end
+
+    def test_provider_existence
+        assert(@provider, "Could not retrieve provider")
+    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.filetype = Puppet::Util::FileType.filetype(:ram)
+    end
+
+    def mkhosthash
+        if defined? @hcount
+            @hcount += 1
+        else
+            @hcount = 1
+        end
+
+        return {
+            :name => "fakehost%s" % @hcount,
+            :ip => "192.168.27.%s" % @hcount,
+            :alias => ["alias%s" % @hcount],
+            :ensure => :present
+        }
+    end
+
+    def mkhost
+        hash = mkhosthash()
+
+        fakemodel = fakemodel(:host, hash[:name])
+
+        host = @provider.new(fakemodel)
+
+        assert(host, "Could not create provider host")
+        hash.each do |name, val|
+            host.send(name.to_s + "=", val)
+        end
+
+        return host
+    end
+
+    # Make sure we convert both directlys correctly using a simple host.
+    def test_basic_isomorphism
+        hash = {:record_type => :parsed, :name => "myhost", :ip => "192.168.43.56", :alias => %w{another host}}
+
+        str = nil
+        assert_nothing_raised do
+            str = @provider.to_line(hash)
+        end
+
+        assert_equal("192.168.43.56\tmyhost\tanother\thost", str)
+
+        newhash = nil
+        assert_nothing_raised do
+            newhash = @provider.parse(str).shift
+        end
+
+        assert_equal(hash, newhash)
+    end
+
+    # Make sure parsing gets comments, blanks, and hosts
+    def test_blanks_and_comments
+        mkfaketype()
+        text = %{# comment one
+
+192.168.43.56\tmyhost\tanother\thost
+    
+# another comment
+192.168.43.57\tanotherhost
+}
+
+        instances = nil
+        assert_nothing_raised do
+            instances = @provider.parse(text)
+        end
+
+        assert_equal([
+            {:record_type => :comment, :line => "# comment one"},
+            {:record_type => :blank, :line => ""},
+            {:record_type => :parsed, :name => "myhost", :ip => "192.168.43.56", :alias => %w{another host}},
+            {:record_type => :blank, :line => "    "},
+            {:record_type => :comment, :line => "# another comment"},
+            {:record_type => :parsed, :name => "anotherhost", :ip => "192.168.43.57"}
+        ], instances)
+
+        newtext = nil
+        assert_nothing_raised do
+            newtext = @provider.to_file(instances).gsub(/^# HEADER.+\n/, '')
+        end
+
+        assert_equal(text, newtext)
+    end
+
+    def test_simplehost
+        mkfaketype
+        @provider.default_target = :yayness
+        file = @provider.target_object(:yayness)
+
+        # Start out with no content.
+        assert_nothing_raised {
+            assert_equal([], @provider.parse(file.read))
+        }
+
+        # Now create a provider
+        host = nil
+        assert_nothing_raised {
+            host = mkhost
+        }
+
+        # Make sure we're still empty
+        assert_nothing_raised {
+            assert_equal([], @provider.parse(file.read))
+        }
+
+        # Try storing it
+        assert_nothing_raised do
+            host.flush
+        end
+
+        # Make sure we get the host back
+        assert_nothing_raised {
+            assert(file.read.include?(host.name),
+                "Did not flush host to disk")
+        }
+
+        # Remove a single field and make sure it gets tossed
+        name = host.alias
+        host.alias = [:absent]
+
+        assert_nothing_raised {
+            host.flush
+            assert(! file.read.include?(name[0]),
+                "Did not remove alias from disk")
+        }
+
+        # Make sure it throws up if we remove a required field
+        host.ip = :absent
+
+        assert_raise(ArgumentError) {
+            host.flush
+        }
+
+        # Now remove the whole object
+        host.ensure = :absent
+        assert_nothing_raised {
+            host.flush
+            assert_equal([], @provider.parse(file.read))
+        }
+    end
+
+    # Parse our sample data and make sure we regenerate it correctly.
+    def test_hostsparse
+        fakedata("data/types/hosts").each do |file| fakedataparse(file) end
+    end
+
+    # Make sure we can modify the file elsewhere and those modifications will
+    # get taken into account.
+    def test_modifyingfile
+        hostfile = tempfile()
+        @provider.default_target = hostfile
+
+        file = @provider.target_object(hostfile)
+
+        hosts = []
+        3.times {
+            h = mkhost()
+            hosts << h
+        }
+
+        hosts.each do |host|
+            host.flush
+        end
+
+        newhost = mkhost()
+        hosts << newhost
+
+        # Now store our new host
+        newhost.flush()
+
+        # Verify we can retrieve that info
+        assert_nothing_raised("Could not retrieve after second write") {
+            @provider.prefetch
+        }
+
+        text = file.read
+
+        instances = @provider.parse(text)
+
+        # And verify that we have data for everything
+        hosts.each { |host|
+            name = host.model[:name]
+            assert(text.include?(name), "Host %s is not in file" % name)
+            hash = host.property_hash
+            assert(! hash.empty?, "Could not find host %s" % name)
+            assert(hash[:ip], "Could not find ip for host %s" % name)
+        }
+    end
+end
+
+# $Id: parsed.rb 2296 2007-03-18 22:48:57Z luke $

data/test/ral/providers/mount/netinfo.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2006-11-12.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+# 
+# if Puppet::Type.type(:mount).provider(:netinfo).suitable?
+# class TestNetinfoMountProvider < Test::Unit::TestCase
+# 	include PuppetTest
+# 	
+# 	def setup
+# 	    super
+# 	    @mount = Puppet::Type.type(:mount)
+#     end
+#     
+#     if Process.uid == 0 and Facter.value(:hostname) == "midden"
+#     def test_mount_nfs
+#         culain = nil
+#         assert_nothing_raised do
+#             culain = @mount.create :name => "/mnt", :device => "culain:/home/luke", :options => "-o -P", :ensure => :present,
+#                 :fstype => "nfs"
+#         end
+#         
+#         assert(culain, "Did not create fs")
+#         
+#         assert_apply(culain)
+# 
+#         assert_nothing_raised do
+#             culain.provider.mount
+#         end
+#         
+#         assert(culain.provider.mounted?, "fs is not considered mounted")
+#         assert_nothing_raised() { culain.provider.unmount }
+#         
+#         culain[:ensure] = :absent
+#         
+#         assert_apply(culain)
+#     end
+#     end
+#     
+#     def test_simple
+#         root = nil
+#         assert_nothing_raised do
+#             root = @mount.create :name => "/", :check => @mount.validproperties
+#         end
+#         
+#         assert_nothing_raised do
+#             root.retrieve
+#         end
+#         
+#         prov = root.provider
+#         
+#         assert_nothing_raised do
+#             assert(prov.device, "Did not value for device")
+#             assert(prov.device != :absent, "Netinfo thinks the root device is missing")
+#         end
+#     end
+# 	
+# 	def test_list
+# 	    list = nil
+# 	    assert_nothing_raised do
+# 	        list = @mount.list
+#         end
+#         assert(list.length > 0)
+#         list.each do |obj|
+#             assert_instance_of(@mount, obj)
+#             assert(obj[:name], "objects do not have names")
+#             p obj
+#             assert(obj.is(:device), "Did not get value for device in %s" % obj[:name])
+#         end
+#         
+#         assert(list.detect { |m| m[:name] == "/"}, "Could not find root fs")
+#     end
+# end
+# end
+
+# $Id: netinfo.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/providers/mount/parsed.rb

@@ -0,0 +1,223 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'puppettest/fileparsing'
+require 'facter'
+
+class TestParsedMounts < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::FileParsing
+
+    def setup
+        super
+        @mount = Puppet.type(:mount)
+        @provider = @mount.provider(:parsed)
+
+        @oldfiletype = @provider.filetype
+    end
+
+    def teardown
+        Puppet::Util::FileType.filetype(:ram).clear
+        @provider.filetype = @oldfiletype
+        @provider.clear
+        super
+    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.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.name
+
+        fakemodel = fakemodel(:mount, hash[:name])
+
+        mount = @provider.new(fakemodel)
+        assert(mount, "Could not create provider mount")
+        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.filetype = Puppet::Util::FileType.filetype(:ram)
+    end
+
+    def test_default_target
+        should = case Facter.value(:operatingsystem)
+        when "Solaris": "/etc/vfstab"
+        else
+            "/etc/fstab"
+        end
+        assert_equal(should, @provider.default_target)
+    end
+
+    def test_simplemount
+        mkfaketype
+        target = @provider.default_target
+
+        # Make sure we start with an empty file
+        assert_equal("", @provider.target_object(target).read,
+            "Got a non-empty starting file")
+
+        # Now create a provider
+        mount = nil
+        assert_nothing_raised {
+            mount = mkmount
+        }
+
+        # Make sure we're still empty
+        assert_equal("", @provider.target_object(target).read,
+            "Got a non-empty starting file")
+
+        # Try flushing it to disk
+        assert_nothing_raised do
+            mount.flush
+        end
+
+        # Make sure it's now in the file.  The file format is validated in
+        # the isomorphic methods.
+        assert(@provider.target_object(target).read.include?("\t%s\t" %
+            mount.property_hash[:name]), "Mount was not written to disk")
+
+        # now make a change
+        assert_nothing_raised { mount.dump = 5 }
+        assert_nothing_raised { mount.flush }
+
+        @provider.prefetch
+        assert_equal(5, mount.dump, "did not flush change to disk")
+    end
+
+    unless Facter["operatingsystem"].value == "Darwin"
+        def test_mountsparse
+            tab = fake_fstab
+            fakedataparse(tab) do
+                # Now just make we've got some mounts we know will be there
+                hashes = @provider.target_records(tab).find_all { |i| i.is_a? Hash }
+                assert(hashes.length > 0, "Did not create any hashes")
+                root = hashes.find { |i| i[:name] == "/" }
+                assert(root, "Could not retrieve root mount")
+            end
+        end
+
+        def test_rootfs
+            fs = nil
+            type = @mount.create :name => "/"
+
+            provider = type.provider
+
+            assert(FileTest.exists?(@provider.default_target),
+                "FSTab %s does not exist" % @provider.default_target)
+            assert_nothing_raised do
+                @provider.prefetch
+            end
+
+            assert_equal(:present, provider.property_hash[:ensure],
+                "Could not find root fs with provider %s" % provider.name)
+
+            assert_nothing_raised {
+                assert(provider.mounted?, "Root is considered not mounted")
+            }
+        end
+    end
+
+    if Puppet.features.root? and Facter.value(:operatingsystem) != "Darwin"
+    def test_mountfs
+        fs = nil
+        case Facter.value(:hostname)
+        when "culain": fs = "/ubuntu"
+        when "atalanta": fs = "/mnt"
+        else
+            $stderr.puts "No mount for mount testing; skipping"
+            return
+        end
+
+        oldtext = @provider.target_object(@provider.default_target).read
+
+        ftype = @provider.filetype
+
+        mount = @mount.create :name => fs
+        obj = mount.provider
+
+        current = nil
+        assert_nothing_raised {
+            current = obj.mounted?
+        }
+
+        if current
+            # Make sure the original gets remounted.
+            cleanup do
+                unless obj.mounted?
+                    obj.mount
+                end
+            end
+        end
+
+        unless current
+            assert_nothing_raised {
+                obj.mount
+            }
+        end
+
+        assert(obj.mounted?, "filesystem is not mounted")
+
+        assert_nothing_raised {
+            obj.unmount
+        }
+        assert(! obj.mounted?, "FS still mounted")
+        # Check the actual output of df
+        assert(! obj.df().include?(fs), "%s is still listed in df" % fs)
+        assert_nothing_raised {
+            obj.mount
+        }
+        assert(obj.mounted?, "FS not mounted")
+        assert(obj.df().include?(fs), "%s is not listed in df" % fs)
+
+        # Now try remounting
+        assert_nothing_raised("Could not remount filesystem") do
+            obj.remount
+        end
+    end
+    end
+
+    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.default_target
+        return fakefile(File::join("data/types/mount", name))
+    end
+end
+
+# $Id: parsed.rb 2445 2007-05-01 03:45:09Z luke $