puppet 0.25.5 → 2.6.0

data/test/ral/type/yumrepo.rb

@@ -6,99 +6,102 @@ require 'puppettest'
 require 'fileutils'
 
 class TestYumRepo < Test::Unit::TestCase
-    include PuppetTest
-
-    def setup
-        super
-        @yumdir = tempfile()
-        Dir.mkdir(@yumdir)
-        @yumconf = File.join(@yumdir, "yum.conf")
-        File.open(@yumconf, "w") do |f|
-            f.print "[main]\nreposdir=#{@yumdir} /no/such/dir\n"
-        end
-        Puppet::Type.type(:yumrepo).yumconf = @yumconf
-
-        # It needs to be reset each time, otherwise the cache is used.
-        Puppet::Type.type(:yumrepo).inifile = nil
+  include PuppetTest
+
+  def setup
+    super
+    @yumdir = tempfile
+    Dir.mkdir(@yumdir)
+    @yumconf = File.join(@yumdir, "yum.conf")
+    File.open(@yumconf, "w") do |f|
+      f.print "[main]\nreposdir=#{@yumdir} /no/such/dir\n"
     end
-
-    # Modify one existing section
-    def test_modify
-        copy_datafiles
-        devel = make_repo("development", { :descr => "New description" })
-        current_values = devel.retrieve
-
-        assert_equal("development", devel[:name])
-        assert_equal('Fedora Core $releasever - Development Tree', current_values[devel.property(:descr)])
-        assert_equal('New description', devel.property(:descr).should)
-        assert_apply(devel)
-
-        inifile = Puppet::Type.type(:yumrepo).read()
-        assert_equal('New description', inifile['development']['name'])
-        assert_equal('Fedora Core $releasever - $basearch - Base', inifile['base']['name'])
-        assert_equal("foo\n  bar\n  baz", inifile['base']['exclude'])
-        assert_equal(['base', 'development', 'main'], all_sections(inifile))
-    end
-
-    # Create a new section
-    def test_create
-        values = {
-            :descr => "Fedora Core $releasever - $basearch - Base",
-            :baseurl => "http://example.com/yum/$releasever/$basearch/os/",
-            :enabled => "1",
-            :gpgcheck => "1",
-            :includepkgs => "absent",
-            :gpgkey => "file:///etc/pki/rpm-gpg/RPM-GPG-KEY-fedora",
-            :proxy => "http://proxy.example.com:80/",
-            :proxy_username => "username",
-            :proxy_password => "password"
-        }
-        repo = make_repo("base", values)
-
-        assert_apply(repo)
-        inifile = Puppet::Type.type(:yumrepo).read()
-        sections = all_sections(inifile)
-        assert_equal(['base', 'main'], sections)
-        text = inifile["base"].format
-        assert_equal(CREATE_EXP, text)
-    end
-
-    # Delete mirrorlist by setting it to :absent and enable baseurl
-    def test_absent
-        copy_datafiles
-        baseurl = 'http://example.com/'
-        devel = make_repo("development",
-                          { :mirrorlist => 'absent',
-                            :baseurl => baseurl })
-        devel.retrieve
-        assert_apply(devel)
-        inifile = Puppet::Type.type(:yumrepo).read()
-        sec = inifile["development"]
-        assert_nil(sec["mirrorlist"])
-        assert_equal(baseurl, sec["baseurl"])
-    end
-
-    def make_repo(name, hash={})
-        hash[:name] = name
-        Puppet::Type.type(:yumrepo).new(hash)
-    end
-
-    def all_sections(inifile)
-        sections = []
-        inifile.each_section { |section| sections << section.name }
-        return sections.sort
-    end
-
-    def copy_datafiles
-        fakedata("data/types/yumrepos").select { |file|
-            file =~ /\.repo$/
-        }.each { |src|
-            dst = File::join(@yumdir, File::basename(src))
-            FileUtils::copy(src, dst)
-        }
-    end
-
-    CREATE_EXP = <<'EOF'
+    Puppet::Type.type(:yumrepo).yumconf = @yumconf
+
+    # It needs to be reset each time, otherwise the cache is used.
+    Puppet::Type.type(:yumrepo).inifile = nil
+  end
+
+  # Modify one existing section
+  def test_modify
+    copy_datafiles
+    devel = make_repo("development", { :descr => "New description" })
+    current_values = devel.retrieve
+
+    assert_equal("development", devel[:name])
+    assert_equal('Fedora Core $releasever - Development Tree', current_values[devel.property(:descr)])
+    assert_equal('New description', devel.property(:descr).should)
+    assert_apply(devel)
+
+    inifile = Puppet::Type.type(:yumrepo).read
+    assert_equal('New description', inifile['development']['name'])
+    assert_equal('Fedora Core $releasever - $basearch - Base', inifile['base']['name'])
+    assert_equal("foo\n  bar\n  baz", inifile['base']['exclude'])
+    assert_equal(['base', 'development', 'main'], all_sections(inifile))
+  end
+
+  # Create a new section
+  def test_create
+    values = {
+      :descr => "Fedora Core $releasever - $basearch - Base",
+      :baseurl => "http://example.com/yum/$releasever/$basearch/os/",
+      :enabled => "1",
+      :gpgcheck => "1",
+      :includepkgs => "absent",
+      :gpgkey => "file:///etc/pki/rpm-gpg/RPM-GPG-KEY-fedora",
+      :proxy => "http://proxy.example.com:80/",
+      :proxy_username => "username",
+      :proxy_password => "password"
+    }
+    repo = make_repo("base", values)
+
+    assert_apply(repo)
+    inifile = Puppet::Type.type(:yumrepo).read
+    sections = all_sections(inifile)
+    assert_equal(['base', 'main'], sections)
+    text = inifile["base"].format
+    assert_equal(CREATE_EXP, text)
+  end
+
+  # Delete mirrorlist by setting it to :absent and enable baseurl
+  def test_absent
+    copy_datafiles
+    baseurl = 'http://example.com/'
+
+      devel = make_repo(
+        "development",
+          { :mirrorlist => 'absent',
+
+            :baseurl => baseurl })
+    devel.retrieve
+    assert_apply(devel)
+    inifile = Puppet::Type.type(:yumrepo).read
+    sec = inifile["development"]
+    assert_nil(sec["mirrorlist"])
+    assert_equal(baseurl, sec["baseurl"])
+  end
+
+  def make_repo(name, hash={})
+    hash[:name] = name
+    Puppet::Type.type(:yumrepo).new(hash)
+  end
+
+  def all_sections(inifile)
+    sections = []
+    inifile.each_section { |section| sections << section.name }
+    sections.sort
+  end
+
+  def copy_datafiles
+    fakedata("data/types/yumrepos").select { |file|
+      file =~ /\.repo$/
+    }.each { |src|
+      dst = File::join(@yumdir, File::basename(src))
+      FileUtils::copy(src, dst)
+    }
+  end
+
+  CREATE_EXP = <<'EOF'
 [base]
 name=Fedora Core $releasever - $basearch - Base
 baseurl=http://example.com/yum/$releasever/$basearch/os/

data/test/ral/type/zone.rb

@@ -6,209 +6,224 @@ require 'puppettest'
 require 'puppet/type/zone'
 
 class TestZone < PuppetTest::TestCase
-    confine "Zones are only functional on Solaris" => (Facter["operatingsystem"].value == "Solaris")
+  confine "Zones are only functional on Solaris" => (Facter["operatingsystem"].value == "Solaris")
 
-    def setup
-        super
-        @@zones = []
-    end
+  def setup
+    super
+    @@zones = []
+  end
 
-    def mkzone(name)
-        zone = nil
+  def mkzone(name)
+    zone = nil
 
-        base = tempfile()
-        Dir.mkdir(base)
-        File.chmod(0700, base)
-        root = File.join(base, "zonebase")
-        assert_nothing_raised {
-            zone = Puppet::Type.type(:zone).new(
-                :name => name,
-                :path => root,
-                :ensure => "configured" # don't want to install zones automatically
-            )
-        }
+    base = tempfile
+    Dir.mkdir(base)
+    File.chmod(0700, base)
+    root = File.join(base, "zonebase")
+    assert_nothing_raised {
 
-        @@zones << name
+      zone = Puppet::Type.type(:zone).new(
 
-        return zone
-    end
+        :name => name,
+        :path => root,
 
-    def test_instances
-        list = nil
-        assert_nothing_raised {
-            list = Puppet::Type.type(:zone).instances
-        }
+        :ensure => "configured" # don't want to install zones automatically
+      )
+    }
 
-        assert(! list.empty?, "Got no zones back")
+    @@zones << name
 
-        assert(list.find { |z| z[:name] == "global" }, "Could not find global zone")
-    end
+    zone
+  end
 
-    def test_state_sequence
-        zone = mkzone("slicetest")
+  def test_instances
+    list = nil
+    assert_nothing_raised {
+      list = Puppet::Type.type(:zone).instances
+    }
 
-        property = zone.property(:ensure)
+    assert(! list.empty?, "Got no zones back")
 
-        slice = nil
-        assert_nothing_raised {
-            slice = property.class.state_sequence(:absent, :installed).collect do |o|
-                o[:name]
-            end
-        }
+    assert(list.find { |z| z[:name] == "global" }, "Could not find global zone")
+  end
 
+  def test_state_sequence
+    zone = mkzone("slicetest")
 
-        assert_equal([:configured, :installed], slice)
+    property = zone.property(:ensure)
 
-        assert_nothing_raised {
-            slice = property.class.state_sequence(:running, :installed).collect do |o|
-                o[:name]
-            end
-        }
+    slice = nil
+    assert_nothing_raised {
+      slice = property.class.state_sequence(:absent, :installed).collect do |o|
+        o[:name]
+      end
+    }
 
 
-        assert_equal(slice, [:installed])
+    assert_equal([:configured, :installed], slice)
 
-    end
+    assert_nothing_raised {
+      slice = property.class.state_sequence(:running, :installed).collect do |o|
+        o[:name]
+      end
+    }
 
-    # Make sure the ensure stuff behaves as we expect
-    def test_zoneensure
-        zone = mkzone("ensurezone")
 
-        property = zone.property(:ensure)
+    assert_equal(slice, [:installed])
 
-        assert(property, "Did not get ensure property")
+  end
 
-        values = nil
-        assert_nothing_raised {
-            values = zone.retrieve
-        }
+  # Make sure the ensure stuff behaves as we expect
+  def test_zoneensure
+    zone = mkzone("ensurezone")
 
-        assert(! property.insync?(values[property]), "Property is somehow in sync")
+    property = zone.property(:ensure)
 
-        assert(property.up?, "Property incorrectly thinks it is not moving up")
+    assert(property, "Did not get ensure property")
 
-        zone[:ensure] = :installed
-        assert(property.up?, "Property incorrectly thinks it is not moving up")
-        zone[:ensure] = :absent
-        assert(! property.up?, "Property incorrectly thinks it is moving up")
-    end
+    values = nil
+    assert_nothing_raised {
+      values = zone.retrieve
+    }
+
+    assert(! property.insync?(values[property]), "Property is somehow in sync")
+
+    assert(property.up?, "Property incorrectly thinks it is not moving up")
 
-    # Make sure all mentioned methods actually exist.
-    def test_zonemethods_exist
-        methods = []
-        zone = mkzone("methodtest")
-
-        property = zone.property(:ensure)
-        assert_nothing_raised {
-            property.class.state_sequence(:absent, :running).each do |st|
-                [:up, :down].each do |m|
-                    if st[m]
-                        methods << st[m]
-                    end
-                end
-            end
-        }
-
-        methods.each do |m|
-            Puppet::Type.type(:zone).suitableprovider.each do |prov|
-                assert(prov.method_defined?(m),
-                    "Zone provider %s does not define method %s" %
-                    [prov.name, m])
-            end
+    zone[:ensure] = :installed
+    assert(property.up?, "Property incorrectly thinks it is not moving up")
+    zone[:ensure] = :absent
+    assert(! property.up?, "Property incorrectly thinks it is moving up")
+  end
+
+  # Make sure all mentioned methods actually exist.
+  def test_zonemethods_exist
+    methods = []
+    zone = mkzone("methodtest")
+
+    property = zone.property(:ensure)
+    assert_nothing_raised {
+      property.class.state_sequence(:absent, :running).each do |st|
+        [:up, :down].each do |m|
+          methods << st[m] if st[m]
         end
+      end
+    }
+
+    methods.each do |m|
+      Puppet::Type.type(:zone).suitableprovider.each do |prov|
+
+        assert(
+          prov.method_defined?(m),
 
+          "Zone provider #{prov.name} does not define method #{m}")
+      end
     end
 
-    # Make sure our property generates the correct text.
-    def test_inherit_property
-        zone = mkzone("configtesting")
-        zone[:ensure] = :configured
+  end
+
+  # Make sure our property generates the correct text.
+  def test_inherit_property
+    zone = mkzone("configtesting")
+    zone[:ensure] = :configured
+
+    assert_nothing_raised {
+      zone[:inherit] = "/usr"
+    }
+    property = zone.property(:inherit)
+    assert(zone, "Did not get 'inherit' property")
+
 
-        assert_nothing_raised {
-            zone[:inherit] = "/usr"
-        }
-        property = zone.property(:inherit)
-        assert(zone, "Did not get 'inherit' property")
+      assert_equal(
+        "add inherit-pkg-dir\nset dir=/usr\nend", property.configtext,
 
-        assert_equal("add inherit-pkg-dir\nset dir=/usr\nend", property.configtext,
-            "Got incorrect config text")
+      "Got incorrect config text")
 
-        zone.provider.inherit = "/usr"
+    zone.provider.inherit = "/usr"
 
-        assert_equal("", property.configtext,
-            "Got incorrect config text")
 
-        # Now we want multiple directories
-        property.should = %w{/usr /sbin /lib}
+      assert_equal(
+        "", property.configtext,
 
-        # The statements are sorted
-        text = "add inherit-pkg-dir
+      "Got incorrect config text")
+
+    # Now we want multiple directories
+    property.should = %w{/usr /sbin /lib}
+
+    # The statements are sorted
+    text = "add inherit-pkg-dir
 set dir=/lib
 end
 add inherit-pkg-dir
 set dir=/sbin
 end"
 
-        assert_equal(text, property.configtext,
-            "Got incorrect config text")
 
-        zone.provider.inherit = %w{/usr /sbin /lib}
-        property.should = %w{/usr /sbin}
+  assert_equal(
+    text, property.configtext,
 
-        text = "remove inherit-pkg-dir dir=/lib"
+      "Got incorrect config text")
 
-        assert_equal(text, property.configtext,
-            "Got incorrect config text")
-    end
+    zone.provider.inherit = %w{/usr /sbin /lib}
+    property.should = %w{/usr /sbin}
+
+    text = "remove inherit-pkg-dir dir=/lib"
+
+
+      assert_equal(
+        text, property.configtext,
+
+      "Got incorrect config text")
+  end
 end
 
 class TestZoneAsRoot < TestZone
-    confine "Not running Zone creation tests" => Puppet.features.root?
-    confine "Zones are only functional on Solaris" => (Facter["operatingsystem"].value == "Solaris")
-
-    def teardown
-        current = %x{zoneadm list -cp}.split("\n").inject({}) { |h, line|
-            ary = line.split(":")
-            h[ary[1]] = ary[2]
-            h
-        }
-
-        # Get rid of any lingering zones
-        @@zones.each do |zone|
-            next unless current.include? zone
-
-            obj = Puppet::Type.type(:zone).new(:name => zone)
-            obj[:ensure] = :absent
-            assert_apply(obj)
-        end
-
-        # We can't delete the temp files until the zones are stopped and removed.
-        super
+  confine "Not running Zone creation tests" => Puppet.features.root?
+  confine "Zones are only functional on Solaris" => (Facter["operatingsystem"].value == "Solaris")
+
+  def teardown
+    current = %x{zoneadm list -cp}.split("\n").inject({}) { |h, line|
+      ary = line.split(":")
+      h[ary[1]] = ary[2]
+      h
+    }
+
+    # Get rid of any lingering zones
+    @@zones.each do |zone|
+      next unless current.include? zone
+
+      obj = Puppet::Type.type(:zone).new(:name => zone)
+      obj[:ensure] = :absent
+      assert_apply(obj)
     end
-    # Make sure our ensure process actually works.
-    def test_ensure_sync
-        zone = mkzone("ensuretesting")
 
-        zone[:ensure] = :configured
+    # We can't delete the temp files until the zones are stopped and removed.
+    super
+  end
+  # Make sure our ensure process actually works.
+  def test_ensure_sync
+    zone = mkzone("ensuretesting")
 
-        assert_apply(zone)
+    zone[:ensure] = :configured
 
-        assert(zone.insync?(zone.retrieve), "Zone is not insync")
-    end
+    assert_apply(zone)
 
-    def test_getconfig
-        zone = mkzone("configtesting")
+    assert(zone.insync?(zone.retrieve), "Zone is not insync")
+  end
 
-        base = tempfile()
-        zone[:path] = base
+  def test_getconfig
+    zone = mkzone("configtesting")
 
-        ip = "192.168.0.1"
-        interface = "bge0"
-        zone[:ip] = "#{interface}:#{ip}"
+    base = tempfile
+    zone[:path] = base
 
-        IO.popen("zonecfg -z configtesting -f -", "w") do |f|
-            f.puts %{create -b
-set zonepath=#{tempfile()}
+    ip = "192.168.0.1"
+    interface = "bge0"
+    zone[:ip] = "#{interface}:#{ip}"
+
+    IO.popen("zonecfg -z configtesting -f -", "w") do |f|
+      f.puts %{create -b
+set zonepath=#{tempfile}
 set autoboot=true
 add inherit-pkg-dir
 set dir=/lib
@@ -230,189 +245,203 @@ set address=#{ip}
 set physical=bge0
 end
 }
-        end
+  end
 
-        assert_equal(0, $?, "Did not successfully create zone")
+  assert_equal(0, $CHILD_STATUS, "Did not successfully create zone")
 
-        hash = nil
-        assert_nothing_raised {
-            hash = zone.provider.send(:getconfig)
-        }
+  hash = nil
+  assert_nothing_raised {
+    hash = zone.provider.send(:getconfig)
+    }
 
-        zone[:check] = [:inherit, :autoboot]
+    zone[:check] = [:inherit, :autoboot]
 
-        values = nil
-        assert_nothing_raised("Could not retrieve zone values") do
-            values = zone.retrieve.inject({}) { |result, newvals| result[newvals[0].name] = newvals[1]; result }
-        end
+    values = nil
+    assert_nothing_raised("Could not retrieve zone values") do
+      values = zone.retrieve.inject({}) { |result, newvals| result[newvals[0].name] = newvals[1]; result }
+    end
 
-        # And make sure it gets set correctly.
-        assert_equal(%w{/sbin /usr /opt/csw /lib /platform}.sort,
-            values[:inherit].sort, "Inherited dirs did not get collected correctly."
-        )
+    # And make sure it gets set correctly.
 
-        assert_equal(["#{interface}:#{ip}"], values[:ip],
-            "IP addresses did not get collected correctly.")
+      assert_equal(
+        %w{/sbin /usr /opt/csw /lib /platform}.sort,
 
-        assert_equal(:true, values[:autoboot],
-            "Autoboot did not get collected correctly.")
-    end
+      values[:inherit].sort, "Inherited dirs did not get collected correctly."
+    )
 
-    # Make sure we can do all the various and sundry configuring things.
-    def test_configuring_zones
-        zone = mkzone("configtesting")
 
-        assert_nothing_raised {
-            zone[:inherit] = "/usr"
-        }
+      assert_equal(
+        ["#{interface}:#{ip}"], values[:ip],
 
-        zone[:ensure] = :configured
+      "IP addresses did not get collected correctly.")
 
-        assert_apply(zone)
 
-        assert(zone.insync?(zone.retrieve), "Zone is not insync")
+        assert_equal(
+          :true, values[:autoboot],
 
-        # Now add a new directory to inherit
-        assert_nothing_raised {
-            zone[:inherit] = ["/sbin", "/usr"]
-        }
-        assert_apply(zone)
+      "Autoboot did not get collected correctly.")
+  end
 
-        assert(zone.insync?(zone.retrieve), "Zone is not insync")
+  # Make sure we can do all the various and sundry configuring things.
+  def test_configuring_zones
+    zone = mkzone("configtesting")
 
-        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /dir: \/sbin/,
-            "sbin was not added")
+    assert_nothing_raised {
+      zone[:inherit] = "/usr"
+    }
 
-        # And then remove it.
-        assert_nothing_raised {
-            zone[:inherit] = "/usr"
-        }
-        assert_apply(zone)
+    zone[:ensure] = :configured
 
-        assert(zone.insync?(zone.retrieve), "Zone is not insync")
+    assert_apply(zone)
 
-        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /dir: \/sbin/,
-            "sbin was not removed")
+    assert(zone.insync?(zone.retrieve), "Zone is not insync")
 
-        # Now add an ip adddress.  Fortunately (or not), zonecfg doesn't verify
-        # that the interface exists.
-        zone[:ip] = "hme0:192.168.0.1"
+    # Now add a new directory to inherit
+    assert_nothing_raised {
+      zone[:inherit] = ["/sbin", "/usr"]
+    }
+    assert_apply(zone)
 
-        assert(! zone.insync?(zone.retrieve), "Zone is marked as in sync")
+    assert(zone.insync?(zone.retrieve), "Zone is not insync")
 
-        assert_apply(zone)
-        assert(zone.insync?(zone.retrieve), "Zone is not in sync")
-        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.1/,
-            "ip was not added")
-        zone[:ip] = ["hme1:192.168.0.2", "hme0:192.168.0.1"]
-        assert_apply(zone)
-        assert(zone.insync?(zone.retrieve), "Zone is not in sync")
-        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.2/,
-            "ip was not added")
-        zone[:ip] = ["hme1:192.168.0.2"]
-        assert_apply(zone)
-        zone.retrieve
-        assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /192.168.0.1/,
-            "ip was not removed")
-    end
 
-    # Test creating and removing a zone, but only up to the configured property,
-    # so it's faster.
-    def test_smallcreate
-        zone = mkzone("smallcreate")
-        # Include a bunch of stuff so the zone isn't as large
-        dirs = %w{/usr /sbin /lib /platform}
+      assert(
+        %x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /dir: \/sbin/,
 
-        %w{/opt/csw}.each do |dir|
-            dirs << dir if FileTest.exists? dir
-        end
-        zone[:inherit] = dirs
+      "sbin was not added")
 
-        assert(zone, "Did not make zone")
+    # And then remove it.
+    assert_nothing_raised {
+      zone[:inherit] = "/usr"
+    }
+    assert_apply(zone)
 
-        zone[:ensure] = :configured
+    assert(zone.insync?(zone.retrieve), "Zone is not insync")
 
-        assert(! zone.insync?(zone.retrieve), "Zone is incorrectly in sync")
 
-        assert_apply(zone)
+      assert(
+        %x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /dir: \/sbin/,
 
-        assert(zone.insync?(zone.retrieve), "Zone is incorrectly out of sync")
+      "sbin was not removed")
 
-        zone[:ensure] = :absent
+    # Now add an ip adddress.  Fortunately (or not), zonecfg doesn't verify
+    # that the interface exists.
+    zone[:ip] = "hme0:192.168.0.1"
 
-        assert_apply(zone)
+    assert(! zone.insync?(zone.retrieve), "Zone is marked as in sync")
 
-        currentvalues = zone.retrieve
+    assert_apply(zone)
+    assert(zone.insync?(zone.retrieve), "Zone is not in sync")
 
-        assert_equal(:absent, currentvalues[zone.property(:ensure)],
-                     "Zone is not absent")
-    end
+      assert(
+        %x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.1/,
 
-    # Just go through each method linearly and make sure it works.
-    def test_each_method
-        zone = mkzone("methodtesting")
-        dirs = %w{/usr /sbin /lib /platform}
+      "ip was not added")
+    zone[:ip] = ["hme1:192.168.0.2", "hme0:192.168.0.1"]
+    assert_apply(zone)
+    assert(zone.insync?(zone.retrieve), "Zone is not in sync")
+    assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /192.168.0.2/, "ip was not added")
+    zone[:ip] = ["hme1:192.168.0.2"]
+    assert_apply(zone)
+    zone.retrieve
+    assert(%x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /192.168.0.1/, "ip was not removed")
+  end
 
-        %w{/opt/csw}.each do |dir|
-            dirs << dir if FileTest.exists? dir
-        end
-        zone[:inherit] = dirs
-
-        [[:configure, :configured],
-            [:install, :installed],
-            [:start, :running],
-            [:stop, :installed],
-            [:uninstall, :configured],
-            [:unconfigure, :absent]
-        ].each do |method, property|
-            Puppet.info "Testing %s" % method
-            current_values = nil
-            assert_nothing_raised {
-                current_values = zone.retrieve
-            }
-            assert_nothing_raised {
-                zone.provider.send(method)
-            }
-            current_values = nil
-            assert_nothing_raised {
-                current_values = zone.retrieve
-            }
-            assert_equal(property, current_values[zone.property(:ensure)],
-                "Method %s did not correctly set property %s" %
-                    [method, property])
-        end
+  # Test creating and removing a zone, but only up to the configured property,
+  # so it's faster.
+  def test_smallcreate
+    zone = mkzone("smallcreate")
+    # Include a bunch of stuff so the zone isn't as large
+    dirs = %w{/usr /sbin /lib /platform}
+
+    %w{/opt/csw}.each do |dir|
+      dirs << dir if FileTest.exists? dir
     end
+    zone[:inherit] = dirs
 
-    def test_mkzone
-        zone = mkzone("testmaking")
-        # Include a bunch of stuff so the zone isn't as large
-        dirs = %w{/usr /sbin /lib /platform}
+    assert(zone, "Did not make zone")
 
-        %w{/opt/csw}.each do |dir|
-            dirs << dir if FileTest.exists? dir
-        end
-        zone[:inherit] = dirs
+    zone[:ensure] = :configured
 
-        assert(zone, "Did not make zone")
+    assert(! zone.insync?(zone.retrieve), "Zone is incorrectly in sync")
 
+    assert_apply(zone)
 
-        [:configured, :installed, :running, :installed, :absent].each do |value|
-            assert_nothing_raised {
-                zone[:ensure] = value
-            }
-            assert(! zone.insync?(zone.retrieve), "Zone is incorrectly in sync")
+    assert(zone.insync?(zone.retrieve), "Zone is incorrectly out of sync")
 
-            assert_apply(zone)
+    zone[:ensure] = :absent
 
-            assert_nothing_raised {
-                assert(zone.insync?(zone.retrieve), "Zone is incorrectly out of sync")
-            }
-        end
+    assert_apply(zone)
+
+    currentvalues = zone.retrieve
+
+    assert_equal(:absent, currentvalues[zone.property(:ensure)],
+      "Zone is not absent")
+  end
 
-        currentvalues = zone.retrieve
+  # Just go through each method linearly and make sure it works.
+  def test_each_method
+    zone = mkzone("methodtesting")
+    dirs = %w{/usr /sbin /lib /platform}
 
-        assert_equal(:absent, currentvalues[zone.property(:ensure)],
-                     "Zone is not absent")
+    %w{/opt/csw}.each do |dir|
+      dirs << dir if FileTest.exists? dir
     end
+    zone[:inherit] = dirs
+
+    [[:configure, :configured],
+      [:install, :installed],
+      [:start, :running],
+      [:stop, :installed],
+      [:uninstall, :configured],
+      [:unconfigure, :absent]
+    ].each do |method, property|
+      Puppet.info "Testing #{method}"
+      current_values = nil
+      assert_nothing_raised {
+        current_values = zone.retrieve
+      }
+      assert_nothing_raised {
+        zone.provider.send(method)
+      }
+      current_values = nil
+      assert_nothing_raised {
+        current_values = zone.retrieve
+      }
+      assert_equal(property, current_values[zone.property(:ensure)], "Method #{method} did not correctly set property #{property}")
+    end
+  end
+
+  def test_mkzone
+    zone = mkzone("testmaking")
+    # Include a bunch of stuff so the zone isn't as large
+    dirs = %w{/usr /sbin /lib /platform}
+
+    %w{/opt/csw}.each do |dir|
+      dirs << dir if FileTest.exists? dir
+    end
+    zone[:inherit] = dirs
+
+    assert(zone, "Did not make zone")
+
+
+    [:configured, :installed, :running, :installed, :absent].each do |value|
+      assert_nothing_raised {
+        zone[:ensure] = value
+      }
+      assert(! zone.insync?(zone.retrieve), "Zone is incorrectly in sync")
+
+      assert_apply(zone)
+
+      assert_nothing_raised {
+        assert(zone.insync?(zone.retrieve), "Zone is incorrectly out of sync")
+      }
+    end
+
+    currentvalues = zone.retrieve
+
+    assert_equal(:absent, currentvalues[zone.property(:ensure)],
+      "Zone is not absent")
+  end
 end