puppet 0.25.5 → 2.6.0

data/test/ral/providers/group.rb

@@ -6,246 +6,237 @@ require 'puppettest'
 require 'etc'
 
 class TestGroupProvider < Test::Unit::TestCase
-    include PuppetTest
-    def setup
-        super
-        @@tmpgroups = []
-        @provider = nil
-        assert_nothing_raised {
-            @provider = Puppet::Type.type(:group).defaultprovider
-        }
-
-        assert(@provider, "Could not find default group provider")
-        assert(@provider.name != :fake, "Got a fake provider")
+  include PuppetTest
+  def setup
+    super
+    @@tmpgroups = []
+    @provider = nil
+    assert_nothing_raised {
+      @provider = Puppet::Type.type(:group).defaultprovider
+    }
+
+    assert(@provider, "Could not find default group provider")
+    assert(@provider.name != :fake, "Got a fake provider")
+  end
+
+  def teardown
+    super
+    @@tmpgroups.each { |group|
+      remove(group) unless missing?(group)
+    }
+  end
+
+  def mkgroup(name, hash = {})
+    fakeresource = stub 'group', :allowdupe? => false, :name => name
+    fakeresource.stubs(:[]).returns nil
+    fakeresource.stubs(:should).returns nil
+    fakeresource.stubs(:[]).with(:name).returns name
+    hash.each do |name, val|
+      fakeresource.stubs(:should).with(name).returns val
+      fakeresource.stubs(:[]).with(name).returns val
     end
+    group = nil
+    assert_nothing_raised {
+      group = @provider.new(fakeresource)
+    }
+    assert(group, "Could not create provider group")
 
-    def teardown
-        super
-        @@tmpgroups.each { |group|
-            unless missing?(group)
-                remove(group)
-            end
-        }
-    end
-
-    def mkgroup(name, hash = {})
-        fakeresource = stub 'group', :allowdupe? => false, :name => name
-        fakeresource.stubs(:[]).returns nil
-        fakeresource.stubs(:should).returns nil
-        fakeresource.stubs(:[]).with(:name).returns name
-        hash.each do |name, val|
-            fakeresource.stubs(:should).with(name).returns val
-            fakeresource.stubs(:[]).with(name).returns val
-        end
-        group = nil
-        assert_nothing_raised {
-            group = @provider.new(fakeresource)
-        }
-        assert(group, "Could not create provider group")
+    group
+  end
 
-        return group
-    end
+  case Facter["operatingsystem"].value
+  when "Darwin"
+    def missing?(group)
+      output = %x{nidump -r /groups/#{group} / 2>/dev/null}.chomp
 
-    case Facter["operatingsystem"].value
-    when "Darwin"
-        def missing?(group)
-            output = %x{nidump -r /groups/#{group} / 2>/dev/null}.chomp
-
-            if output == ""
-                return true
-            else
-                return false
-            end
-
-            assert_equal("", output, "Group %s is present:\n%s" % [group, output])
-        end
+      return output == ""
 
-        def gid(name)
-            %x{nireport / /groups name gid}.split("\n").each { |line|
-                group, id = line.chomp.split(/\s+/)
-                assert(id =~ /^-?\d+$/, "Group id %s for %s is not a number" %
-                    [id.inspect, group])
-                if group == name
-                    return Integer(id)
-                end
-            }
-
-            return nil
-        end
-
-        def remove(group)
-            system("niutil -destroy / /groups/%s" % group)
-        end
-    else
-        def missing?(group)
-            begin
-                obj = Etc.getgrnam(group)
-                return false
-            rescue ArgumentError
-                return true
-            end
-        end
-
-        def gid(name)
-            assert_nothing_raised {
-                obj = Etc.getgrnam(name)
-                return obj.gid
-            }
+      assert_equal("", output, "Group #{group} is present:\n#{output}")
+    end
 
-            return nil
+    def gid(name)
+      %x{nireport / /groups name gid}.split("\n").each { |line|
+        group, id = line.chomp.split(/\s+/)
+        assert(id =~ /^-?\d+$/, "Group id #{id.inspect} for #{group} is not a number")
+        if group == name
+          return Integer(id)
         end
+      }
 
-        def remove(group)
-            system("groupdel %s" % group)
-        end
+      nil
     end
 
-    def groupnames
-        %x{groups}.chomp.split(/ /)
+    def remove(group)
+      system("niutil -destroy / /groups/#{group}")
     end
-
-    def groupids
-        Process.groups
+  else
+    def missing?(group)
+        obj = Etc.getgrnam(group)
+        return false
+    rescue ArgumentError
+        return true
     end
 
-    def attrtest_ensure(group)
-        old = group.ensure
-        assert_nothing_raised {
-            group.delete
-        }
-
-        assert(!group.exists?, "Group was not deleted")
+    def gid(name)
+      assert_nothing_raised {
+        obj = Etc.getgrnam(name)
+        return obj.gid
+      }
 
-        assert_nothing_raised {
-            group.create
-        }
-        assert(group.exists?, "Group was not created")
+      nil
+    end
 
-        unless old == :present
-            assert_nothing_raised {
-                group.delete
-            }
-        end
+    def remove(group)
+      system("groupdel #{group}")
     end
+  end
 
-    def attrtest_gid(group)
-        old = gid(group.name)
-
-        newgid = old
-        while true
-            newgid += 1
-
-            if newgid - old > 1000
-                $stderr.puts "Could not find extra test UID"
-                return
-            end
-            begin
-                Etc.getgrgid(newgid)
-            rescue ArgumentError => detail
-                break
-            end
-        end
+  def groupnames
+    %x{groups}.chomp.split(/ /)
+  end
 
-        assert_nothing_raised("Failed to change group id") {
-            group.gid = newgid
-        }
+  def groupids
+    Process.groups
+  end
 
-        curgid = nil
-        assert_nothing_raised {
-            curgid = gid(group.name)
-        }
+  def attrtest_ensure(group)
+    old = group.ensure
+    assert_nothing_raised {
+      group.delete
+    }
 
-        assert_equal(newgid, curgid, "GID was not changed")
-        # Refresh
-        group.getinfo(true)
-        assert_equal(newgid, group.gid, "Object got wrong gid")
+    assert(!group.exists?, "Group was not deleted")
 
-        assert_nothing_raised("Failed to change group id") {
-            group.gid = old
-        }
-    end
+    assert_nothing_raised {
+      group.create
+    }
+    assert(group.exists?, "Group was not created")
 
-    # Iterate over each of our groups and try to grab the gid.
-    def test_ownprovidergroups
-        groupnames().each { |group|
-            gobj = nil
-            comp = nil
-            fakeresource = fakeresource(:group, group)
-            assert_nothing_raised {
-                gobj = @provider.new(fakeresource)
-            }
-
-            assert(gobj.gid, "Failed to retrieve gid")
-        }
+    unless old == :present
+      assert_nothing_raised {
+        group.delete
+      }
+    end
+  end
+
+  def attrtest_gid(group)
+    old = gid(group.name)
+
+    newgid = old
+    while true
+      newgid += 1
+
+      if newgid - old > 1000
+        $stderr.puts "Could not find extra test UID"
+        return
+      end
+      begin
+        Etc.getgrgid(newgid)
+      rescue ArgumentError => detail
+        break
+      end
     end
 
-    if Puppet::Util::SUIDManager.uid == 0
-        def test_mkgroup
-            gobj = nil
-            comp = nil
-            name = "pptestgr"
-            assert(missing?(name), "Group %s is still present" % name)
-            group = mkgroup(name)
-
-            @@tmpgroups << name
-
-            assert(group.respond_to?(:addcmd), "no respondo?")
-            assert_nothing_raised {
-                group.create
-            }
-            assert(!missing?(name), "Group %s is missing" % name)
-
-            tests = Puppet::Type.type(:group).validproperties
-
-            tests.each { |test|
-                if self.respond_to?("attrtest_%s" % test)
-                    self.send("attrtest_%s" % test, group)
-                else
-                    $stderr.puts "Not testing attr %s of group" % test
-                end
-            }
-
-            assert_nothing_raised {
-                group.delete
-            }
+    assert_nothing_raised("Failed to change group id") {
+      group.gid = newgid
+    }
+
+    curgid = nil
+    assert_nothing_raised {
+      curgid = gid(group.name)
+    }
+
+    assert_equal(newgid, curgid, "GID was not changed")
+    # Refresh
+    group.getinfo(true)
+    assert_equal(newgid, group.gid, "Object got wrong gid")
+
+    assert_nothing_raised("Failed to change group id") {
+      group.gid = old
+    }
+  end
+
+  # Iterate over each of our groups and try to grab the gid.
+  def test_ownprovidergroups
+    groupnames.each { |group|
+      gobj = nil
+      comp = nil
+      fakeresource = fakeresource(:group, group)
+      assert_nothing_raised {
+        gobj = @provider.new(fakeresource)
+      }
+
+      assert(gobj.gid, "Failed to retrieve gid")
+    }
+  end
+
+  if Puppet.features.root?
+    def test_mkgroup
+      gobj = nil
+      comp = nil
+      name = "pptestgr"
+      assert(missing?(name), "Group #{name} is still present")
+      group = mkgroup(name)
+
+      @@tmpgroups << name
+
+      assert(group.respond_to?(:addcmd), "no respondo?")
+      assert_nothing_raised {
+        group.create
+      }
+      assert(!missing?(name), "Group #{name} is missing")
+
+      tests = Puppet::Type.type(:group).validproperties
+
+      tests.each { |test|
+        if self.respond_to?("attrtest_#{test}")
+          self.send("attrtest_#{test}", group)
+        else
+          $stderr.puts "Not testing attr #{test} of group"
         end
+      }
 
-        # groupadd -o is broken in FreeBSD.
-        unless Facter["operatingsystem"].value == "FreeBSD"
-        def test_duplicateIDs
-            group1 = mkgroup("group1", :gid => 125)
-
-            @@tmpgroups << "group1"
-            @@tmpgroups << "group2"
-            # Create the first group
-            assert_nothing_raised {
-                group1.create
-            }
-
-            # Not all OSes fail here, so we can't test that it doesn't work with
-            # it off, only that it does work with it on.
-            group2 = mkgroup("group2", :gid => 125)
-            group2.resource.stubs(:allowdupe?).returns true
-
-            # Now create the second group
-            assert_nothing_raised {
-                group2.create
-            }
-            assert_equal(:present, group2.ensure, "Group did not get created")
-        end
-        end
-    else
-        $stderr.puts "Not running as root; skipping group creation tests."
+      assert_nothing_raised {
+        group.delete
+      }
     end
 
-    def test_autogen
-        provider = nil
-        group = Puppet::Type.type(:group).new(:name => nonrootgroup.name)
-        provider = group.provider
-        assert(provider, "did not get provider")
-
-        # Everyone should be able to autogenerate a uid
-        assert_instance_of(Fixnum, provider.autogen(:gid))
+    # groupadd -o is broken in FreeBSD.
+    unless Facter["operatingsystem"].value == "FreeBSD"
+    def test_duplicateIDs
+      group1 = mkgroup("group1", :gid => 125)
+
+      @@tmpgroups << "group1"
+      @@tmpgroups << "group2"
+      # Create the first group
+      assert_nothing_raised {
+        group1.create
+      }
+
+      # Not all OSes fail here, so we can't test that it doesn't work with
+      # it off, only that it does work with it on.
+      group2 = mkgroup("group2", :gid => 125)
+      group2.resource.stubs(:allowdupe?).returns true
+
+      # Now create the second group
+      assert_nothing_raised {
+        group2.create
+      }
+      assert_equal(:present, group2.ensure, "Group did not get created")
+    end
     end
+  else
+    $stderr.puts "Not running as root; skipping group creation tests."
+  end
+
+  def test_autogen
+    provider = nil
+    group = Puppet::Type.type(:group).new(:name => nonrootgroup.name)
+    provider = group.provider
+    assert(provider, "did not get provider")
+
+    # Everyone should be able to autogenerate a uid
+    assert_instance_of(Fixnum, provider.autogen(:gid))
+  end
 end
 

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

@@ -8,86 +8,86 @@ require 'puppettest/fileparsing'
 require 'test/unit'
 
 class TestParsedHostProvider < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::FileParsing
-
-    def setup
-        super
-        @provider = Puppet::Type.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,
-            :host_aliases => ["alias%s" % @hcount],
-            :ensure => :present
-        }
+  include PuppetTest
+  include PuppetTest::FileParsing
+
+  def setup
+    super
+    @provider = Puppet::Type.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
 
-    def mkhost
-        hash = mkhosthash()
+    return {
+      :name => "fakehost#{@hcount}",
+      :ip => "192.168.27.#{@hcount}",
+      :host_aliases => ["alias#{@hcount}"],
+      :ensure => :present
+    }
+  end
 
-        fakeresource = fakeresource(:host, hash[:name])
+  def mkhost
+    hash = mkhosthash
 
-        host = @provider.new(fakeresource)
+    fakeresource = fakeresource(:host, hash[:name])
 
-        assert(host, "Could not create provider host")
-        hash.each do |name, val|
-            host.send(name.to_s + "=", val)
-        end
+    host = @provider.new(fakeresource)
 
-        return host
+    assert(host, "Could not create provider host")
+    hash.each do |name, val|
+      host.send(name.to_s + "=", val)
     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", :host_aliases => %w{another host}}
+    host
+  end
 
-        str = nil
-        assert_nothing_raised do
-            str = @provider.to_line(hash)
-        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", :host_aliases => %w{another host}}
 
-        assert_equal("192.168.43.56\tmyhost\tanother\thost", str)
+    str = nil
+    assert_nothing_raised do
+      str = @provider.to_line(hash)
+    end
 
-        newhash = nil
-        assert_nothing_raised do
-            newhash = @provider.parse(str).shift
-        end
+    assert_equal("192.168.43.56\tmyhost\tanother\thost", str)
 
-        assert_equal(hash, newhash)
+    newhash = nil
+    assert_nothing_raised do
+      newhash = @provider.parse(str).shift
     end
 
-    # Make sure parsing gets comments, blanks, and hosts
-    def test_blanks_and_comments
-        mkfaketype()
-        text = %{# comment one
+    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
     
@@ -95,131 +95,140 @@ class TestParsedHostProvider < Test::Unit::TestCase
 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", :host_aliases => %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)
+    instances = nil
+    assert_nothing_raised do
+      instances = @provider.parse(text)
     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.host_aliases
-        host.host_aliases = [:absent]
-
-        assert_nothing_raised {
-            host.flush
-            assert(! file.read.include?(name[0]),
-                "Did not remove host_aliases 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
+          assert_equal(
+        [
+      {:record_type => :comment, :line => "# comment one"},
+      {:record_type => :blank, :line => ""},
+      {:record_type => :parsed, :name => "myhost", :ip => "192.168.43.56", :host_aliases => %w{another host}},
+      {:record_type => :blank, :line => "    "},
+      {:record_type => :comment, :line => "# another comment"},
+        
+      {:record_type => :parsed, :name => "anotherhost", :ip => "192.168.43.57", :host_aliases => []}
+    ], instances)
+
+    newtext = nil
+    assert_nothing_raised do
+      newtext = @provider.to_file(instances).gsub(/^# HEADER.+\n/, '')
     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
-        }
+    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
 
-        hosts.each do |host|
-            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.host_aliases
+    host.host_aliases = [:absent]
+
+    assert_nothing_raised {
+      host.flush
+
+            assert(
+        ! file.read.include?(name[0]),
+        
+        "Did not remove host_aliases 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
+    newhost = mkhost
+    hosts << newhost
 
-        # Now store our new host
-        newhost.flush()
+    # Now store our new host
+    newhost.flush
 
-        # Verify we can retrieve that info
-        assert_nothing_raised("Could not retrieve after second write") {
-            @provider.prefetch
-        }
+    # Verify we can retrieve that info
+    assert_nothing_raised("Could not retrieve after second write") {
+      @provider.prefetch
+    }
 
-        text = file.read
+    text = file.read
 
-        instances = @provider.parse(text)
+    instances = @provider.parse(text)
 
-        # And verify that we have data for everything
-        hosts.each { |host|
-            name = host.resource[: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
+    # And verify that we have data for everything
+    hosts.each { |host|
+      name = host.resource[:name]
+      assert(text.include?(name), "Host #{name} is not in file")
+      hash = host.property_hash
+      assert(! hash.empty?, "Could not find host #{name}")
+      assert(hash[:ip], "Could not find ip for host #{name}")
+    }
+  end
 end