puppet 2.7.26 → 3.0.0.rc4

data/test/ral/type/user.rb

@@ -1,167 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
-
-require 'puppettest'
-require 'etc'
-
-class TestUser < Test::Unit::TestCase
-  include PuppetTest
-
-  p = Puppet::Type.type(:user).provide :fake, :parent => PuppetTest::FakeProvider do
-    @name = :fake
-    apimethods
-    def create
-      @ensure = :present
-      @resource.send(:properties).each do |property|
-        next if property.name == :ensure
-        property.sync
-      end
-    end
-
-    def delete
-      @ensure = :absent
-      @resource.send(:properties).each do |property|
-        send(property.name.to_s + "=", :absent)
-      end
-    end
-
-    def exists?
-      if @ensure == :present
-        true
-      else
-        false
-      end
-    end
-  end
-
-  FakeUserProvider = p
-
-  @@fakeproviders[:group] = p
-
-  def findshell(old = nil)
-    %w{/bin/sh /bin/bash /sbin/sh /bin/ksh /bin/zsh /bin/csh /bin/tcsh
-      /usr/bin/sh /usr/bin/bash /usr/bin/ksh /usr/bin/zsh /usr/bin/csh
-      /usr/bin/tcsh}.find { |shell|
-        if old
-          FileTest.exists?(shell) and shell != old
-        else
-          FileTest.exists?(shell)
-        end
-    }
-  end
-
-  def setup
-    super
-    Puppet::Type.type(:user).defaultprovider = FakeUserProvider
-  end
-
-  def teardown
-    Puppet::Type.type(:user).defaultprovider = nil
-    super
-  end
-
-  def mkuser(name)
-    user = nil
-    assert_nothing_raised {
-
-            user = Puppet::Type.type(:user).new(
-                
-        :name => name,
-        :comment => "Puppet Testing User",
-        :gid => Puppet::Util::SUIDManager.gid,
-        :shell => findshell,
-        
-        :home => "/home/#{name}"
-      )
-    }
-
-    assert(user, "Did not create user")
-
-    user
-  end
-
-  def test_autorequire
-    file = tempfile
-    comp = nil
-    user = nil
-    group =nil
-    home = nil
-    ogroup = nil
-    assert_nothing_raised {
-
-            user = Puppet::Type.type(:user).new(
-                
-        :name => "pptestu",
-        :home => file,
-        :gid => "pptestg",
-        
-        :groups => "yayness"
-      )
-
-            home = Puppet::Type.type(:file).new(
-                
-        :path => file,
-        :owner => "pptestu",
-        
-        :ensure => "directory"
-      )
-      group = Puppet::Type.type(:group).new(
-        :name => "pptestg"
-      )
-      ogroup = Puppet::Type.type(:group).new(
-        :name => "yayness"
-      )
-      comp = mk_catalog(user, group, home, ogroup)
-    }
-
-    rels = nil
-    assert_nothing_raised { rels = user.autorequire }
-
-    assert(rels.detect { |r| r.source == group }, "User did not require group")
-    assert(rels.detect { |r| r.source == ogroup }, "User did not require other groups")
-    assert_nothing_raised { rels = home.autorequire }
-    assert(rels.detect { |r| r.source == user }, "Homedir did not require user")
-  end
-
-  # Testing #455
-  def test_autorequire_with_no_group_should
-    user = Puppet::Type.type(:user).new(:name => "yaytest", :check => :all)
-    catalog = mk_catalog(user)
-
-    assert_nothing_raised do
-      user.autorequire
-    end
-
-    user[:ensure] = :absent
-
-    assert(user.property(:groups).insync?(nil),
-      "Groups state considered out of sync with no :should value")
-  end
-
-  # Make sure the 'managehome' param can only be set when the provider
-  # has that feature.  Uses a patch from #432.
-  def test_managehome
-    user = Puppet::Type.type(:user).new(:name => "yaytest", :check => :all)
-
-    prov = user.provider
-
-    home = false
-    prov.class.meta_def(:manages_homedir?) { home }
-
-    assert_nothing_raised("failed on false managehome") do
-      user[:managehome] = false
-    end
-
-    assert_raise(Puppet::Error, "did not fail when managehome? is false") do
-      user[:managehome] = true
-    end
-
-    home = true
-    assert(prov.class.manages_homedir?, "provider did not enable homedir")
-    assert_nothing_raised("failed when managehome is true") do
-      user[:managehome] = true
-    end
-  end
-end
-

data/test/ral/type/yumrepo.rb

@@ -1,116 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
-
-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
-  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/
-enabled=1
-gpgcheck=1
-gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-fedora
-proxy=http://proxy.example.com:80/
-proxy_username=username
-proxy_password=password
-EOF
-
-end

data/test/ral/type/zone.rb

@@ -1,447 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
-
-require 'puppettest'
-require 'puppet/type/zone'
-
-class TestZone < PuppetTest::TestCase
-  confine "Zones are only functional on Solaris" => (Facter["operatingsystem"].value == "Solaris")
-
-  def setup
-    super
-    @@zones = []
-  end
-
-  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
-      )
-    }
-
-    @@zones << name
-
-    zone
-  end
-
-  def test_instances
-    list = nil
-    assert_nothing_raised {
-      list = Puppet::Type.type(:zone).instances
-    }
-
-    assert(! list.empty?, "Got no zones back")
-
-    assert(list.find { |z| z[:name] == "global" }, "Could not find global zone")
-  end
-
-  def test_state_sequence
-    zone = mkzone("slicetest")
-
-    property = zone.property(:ensure)
-
-    slice = nil
-    assert_nothing_raised {
-      slice = property.class.state_sequence(:absent, :installed).collect do |o|
-        o[:name]
-      end
-    }
-
-
-    assert_equal([:configured, :installed], slice)
-
-    assert_nothing_raised {
-      slice = property.class.state_sequence(:running, :installed).collect do |o|
-        o[:name]
-      end
-    }
-
-
-    assert_equal(slice, [:installed])
-
-  end
-
-  # Make sure the ensure stuff behaves as we expect
-  def test_zoneensure
-    zone = mkzone("ensurezone")
-
-    property = zone.property(:ensure)
-
-    assert(property, "Did not get ensure property")
-
-    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")
-
-    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
-
-  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_equal(
-        "add inherit-pkg-dir\nset dir=/usr\nend", property.configtext,
-
-      "Got incorrect config text")
-
-    zone.provider.inherit = "/usr"
-
-
-      assert_equal(
-        "", property.configtext,
-
-      "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}
-
-    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
-  end
-  # Make sure our ensure process actually works.
-  def test_ensure_sync
-    zone = mkzone("ensuretesting")
-
-    zone[:ensure] = :configured
-
-    assert_apply(zone)
-
-    assert(zone.insync?(zone.retrieve), "Zone is not insync")
-  end
-
-  def test_getconfig
-    zone = mkzone("configtesting")
-
-    base = tempfile
-    zone[:path] = base
-
-    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
-end
-add inherit-pkg-dir
-set dir=/platform
-end
-add inherit-pkg-dir
-set dir=/sbin
-end
-add inherit-pkg-dir
-set dir=/opt/csw
-end
-add inherit-pkg-dir
-set dir=/usr
-end
-add net
-set address=#{ip}
-set physical=bge0
-end
-}
-  end
-
-  assert_equal(0, $CHILD_STATUS, "Did not successfully create zone")
-
-  hash = nil
-  assert_nothing_raised {
-    hash = zone.provider.send(:getconfig)
-    }
-
-    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
-
-    # 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."
-    )
-
-
-      assert_equal(
-        ["#{interface}:#{ip}"], values[:ip],
-
-      "IP addresses did not get collected correctly.")
-
-
-        assert_equal(
-          :true, values[:autoboot],
-
-      "Autoboot did not get collected correctly.")
-  end
-
-  # 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"
-    }
-
-    zone[:ensure] = :configured
-
-    assert_apply(zone)
-
-    assert(zone.insync?(zone.retrieve), "Zone is not insync")
-
-    # Now add a new directory to inherit
-    assert_nothing_raised {
-      zone[:inherit] = ["/sbin", "/usr"]
-    }
-    assert_apply(zone)
-
-    assert(zone.insync?(zone.retrieve), "Zone is not insync")
-
-
-      assert(
-        %x{/usr/sbin/zonecfg -z #{zone[:name]} info} =~ /dir: \/sbin/,
-
-      "sbin was not added")
-
-    # And then remove it.
-    assert_nothing_raised {
-      zone[:inherit] = "/usr"
-    }
-    assert_apply(zone)
-
-    assert(zone.insync?(zone.retrieve), "Zone is not insync")
-
-
-      assert(
-        %x{/usr/sbin/zonecfg -z #{zone[:name]} info} !~ /dir: \/sbin/,
-
-      "sbin was not removed")
-
-    # Now add an ip adddress.  Fortunately (or not), zonecfg doesn't verify
-    # that the interface exists.
-    zone[:ip] = "hme0:192.168.0.1"
-
-    assert(! zone.insync?(zone.retrieve), "Zone is marked as in sync")
-
-    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}
-
-    %w{/opt/csw}.each do |dir|
-      dirs << dir if FileTest.exists? dir
-    end
-    zone[:inherit] = dirs
-
-    assert(zone, "Did not make zone")
-
-    zone[:ensure] = :configured
-
-    assert(! zone.insync?(zone.retrieve), "Zone is incorrectly in sync")
-
-    assert_apply(zone)
-
-    assert(zone.insync?(zone.retrieve), "Zone is incorrectly out of sync")
-
-    zone[:ensure] = :absent
-
-    assert_apply(zone)
-
-    currentvalues = zone.retrieve
-
-    assert_equal(:absent, currentvalues[zone.property(:ensure)],
-      "Zone is not absent")
-  end
-
-  # Just go through each method linearly and make sure it works.
-  def test_each_method
-    zone = mkzone("methodtesting")
-    dirs = %w{/usr /sbin /lib /platform}
-
-    %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
-