puppet 2.7.26 → 3.0.0.rc4

data/test/ral/providers/service/base.rb

@@ -1,76 +0,0 @@
-#!/usr/bin/env ruby
-require File.expand_path(File.dirname(__FILE__) + '/../../../lib/puppettest')
-
-require 'puppettest'
-
-class TestBaseServiceProvider < Test::Unit::TestCase
-  include PuppetTest
-
-  def test_base
-    running = tempfile
-
-    commands = {}
-    %w{touch rm test}.each do |c|
-      path = %x{which #{c}}.chomp
-      if path == ""
-        $stderr.puts "Cannot find '#{c}'; cannot test base service provider"
-        return
-      end
-      commands[c.to_sym] = path
-    end
-
-          service = Puppet::Type.type(:service).new(
-                
-      :name => "yaytest", :provider => :base,
-      :start => "#{commands[:touch]} #{running}",
-      :status => "#{commands[:test]} -f #{running}",
-        
-      :stop => "#{commands[:rm]} #{running}"
-    )
-
-    provider = service.provider
-    assert(provider, "did not get base provider")
-
-    assert_nothing_raised do
-      provider.start
-    end
-    assert(FileTest.exists?(running), "start was not called correctly")
-    assert_nothing_raised do
-      assert_equal(:running, provider.status, "status was not returned correctly")
-    end
-    assert_nothing_raised do
-      provider.stop
-    end
-    assert(! FileTest.exists?(running), "stop was not called correctly")
-    assert_nothing_raised do
-      assert_equal(:stopped, provider.status, "status was not returned correctly")
-    end
-  end
-
-  # Testing #454
-  def test_that_failures_propagate
-    nope = "/no/such/command"
-
-          service = Puppet::Type.type(:service).new(
-                
-      :name => "yaytest", :provider => :base,
-      :start => nope,
-      :status => nope,
-      :stop => nope,
-        
-      :restart => nope
-    )
-
-    provider = service.provider
-    assert(provider, "did not get base provider")
-
-    # We can't fail well when status is messed up, because we depend on the return code
-    # of the command for data.
-    %w{start stop restart}.each do |command|
-      assert_raise(Puppet::Error, "did not throw error when #{command} failed") do
-        provider.send(command)
-      end
-    end
-  end
-end
-

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

@@ -1,112 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../../lib/puppettest')
-
-require 'puppettest'
-require 'puppettest/fileparsing'
-
-class TestParsedSSHKey < Test::Unit::TestCase
-  include PuppetTest
-  include PuppetTest::FileParsing
-
-  def setup
-    super
-    @provider = Puppet::Type.type(:sshkey).provider(:parsed)
-
-    @oldfiletype = @provider.filetype
-  end
-
-  def teardown
-    Puppet::Util::FileType.filetype(:ram).clear
-    @provider.filetype = @oldfiletype
-    @provider.clear
-    super
-  end
-
-  def mkkey(name = "host.domain.com")
-    if defined?(@pcount)
-      @pcount += 1
-    else
-      @pcount = 1
-    end
-    args = {
-      :name => name || "/fspuppet#{@pcount}",
-      :key => "thisismykey#{@pcount}",
-      :host_aliases => ["host1.domain.com","192.168.0.1"],
-      :type => "dss",
-      :ensure => :present
-    }
-
-    fakeresource = fakeresource(:sshkey, args[:name])
-
-    key = @provider.new(fakeresource)
-    args.each do |p,v|
-      key.send(p.to_s + "=", v)
-    end
-
-    key
-  end
-
-  def test_keysparse
-    fakedata("data/types/sshkey").each { |file|
-      fakedataparse(file)
-    }
-  end
-
-  def test_simplekey
-    @provider.filetype = :ram
-    file = @provider.default_target
-
-    key = nil
-    assert_nothing_raised do
-      key = mkkey
-    end
-
-    assert(key, "did not create key")
-
-    assert_nothing_raised do
-      key.flush
-    end
-
-    assert(key.host_aliases, "No host_aliases set for key")
-
-    hash = key.property_hash.dup
-    text = @provider.target_object(file).read
-    names = [key.name, key.host_aliases].flatten.join(",")
-
-    assert_equal("#{names} #{key.type} #{key.key}\n", text)
-
-    assert_nothing_raised do
-      @provider.prefetch
-    end
-
-    hash.each do |p, v|
-      next unless key.respond_to?(p)
-      assert_equal(v, key.send(p), "#{p} did not match")
-    end
-
-    assert(key.name !~ /,/, "Aliases were not split out during parsing")
-  end
-
-  def test_hooks
-    result = nil
-    assert_nothing_raised("Could not call post hook") do
-      result = @provider.parse_line("one,two type key")
-    end
-    assert_equal("one", result[:name], "Did not call post hook")
-    assert_equal(%w{two}, result[:host_aliases], "Did not call post hook")
-
-
-          assert_equal(
-        "one,two type key",
-      @provider.to_line(:record_type => :parsed,
-      :name => "one",
-      :host_aliases => %w{two},
-      :type => "type",
-        
-      :key => "key"),
-      "Did not use pre-hook when generating line"
-    )
-  end
-end
-

data/test/ral/providers/user.rb

@@ -1,586 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
-
-require 'puppettest'
-require 'puppettest/support/utils'
-
-class TestUserProvider < Test::Unit::TestCase
-  include PuppetTest::Support::Utils
-  include PuppetTest::FileTesting
-
-  def setup
-    super
-    setme
-    @@tmpusers = []
-    @provider = nil
-    assert_nothing_raised {
-      @provider = Puppet::Type.type(:user).defaultprovider
-    }
-
-    assert(@provider, "Could not find default user provider")
-
-  end
-
-  def teardown
-    @@tmpusers.each { |user|
-      remove(user) unless missing?(user)
-    }
-    super
-  end
-
-  case Facter["operatingsystem"].value
-  when "Darwin"
-    def missing?(user)
-      output = %x{nidump -r /users/#{user} / 2>/dev/null}.chomp
-
-      return output == ""
-
-      assert_equal("", output, "User #{user} is present:\n#{output}")
-    end
-
-    def current?(param, user)
-      property = Puppet::Type.type(:user).properties.find { |st|
-        st.name == param
-      }
-
-      prov = Puppet::Type.type(:user).defaultprovider
-      output = prov.report(param)
-      output.each { |hash|
-        if hash[:name] == user.name
-          val = hash[param]
-          if val =~ /^[-0-9]+$/
-            return Integer(val)
-          else
-            return val
-          end
-        end
-      }
-
-      nil
-    end
-
-    def remove(user)
-      system("niutil -destroy / /users/#{user}")
-    end
-  else
-    def missing?(user)
-        obj = Etc.getpwnam(user)
-        return false
-    rescue ArgumentError
-        return true
-    end
-
-    def current?(param, user)
-      property = Puppet::Type.type(:user).properties.find { |st|
-        st.name == param
-      }
-
-      assert_nothing_raised {
-        obj = Etc.getpwnam(user.name)
-        return obj.send(user.posixmethod(param))
-      }
-
-      nil
-    end
-
-    def remove(user)
-      system("userdel #{user}")
-    end
-  end
-
-
-  def eachproperty
-    Puppet::Type.type(:user).validproperties.each do |property|
-      yield property
-    end
-  end
-
-  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 fakedata(name, param)
-    case param
-    when :name; name
-    when :ensure; :present
-    when :comment; "Puppet's Testing User #{name}" # use a single quote a la #375
-    when :gid; nonrootgroup.gid
-    when :shell; findshell
-    when :home; "/home/#{name}"
-    else
-      return nil
-    end
-  end
-
-  def fakeresource(*args)
-    resource = super
-
-    # Set boolean methods as necessary.
-    class << resource
-      def allowdupe?
-        self[:allowdupe]
-      end
-      def managehome?
-        self[:managehome]
-      end
-    end
-    resource
-  end
-
-  def mkuser(name)
-    fakeresource = fakeresource(:user, name)
-    user = nil
-    assert_nothing_raised {
-      user = @provider.new(fakeresource)
-    }
-    assert(user, "Could not create provider user")
-
-    user
-  end
-
-  def test_list
-    names = nil
-    assert_nothing_raised {
-      names = @provider.listbyname
-    }
-
-    assert(names.length > 0, "Listed no users")
-
-    # Now try it by object
-    assert_nothing_raised {
-      names = @provider.instances
-    }
-    assert(names.length > 0, "Listed no users as objects")
-
-    names.each do |obj|
-      assert_instance_of(@provider, obj)
-    end
-  end
-
-  def test_infocollection
-    fakeresource = fakeresource(:user, @me)
-
-    user = nil
-    assert_nothing_raised {
-      user = @provider.new(fakeresource)
-    }
-    assert(user, "Could not create user provider")
-
-    Puppet::Type.type(:user).validproperties.each do |property|
-      next if property == :ensure
-      # This is mostly in place for the 'password' stuff.
-      next unless user.class.supports_parameter?(property) and Puppet.features.root?
-      val = nil
-      assert_nothing_raised {
-        val = user.send(property)
-      }
-
-
-        assert(
-          val != :absent,
-
-          "Property #{property} is missing")
-
-      assert(val, "Did not get value for #{property}")
-    end
-  end
-
-  def test_exists
-    user = mkuser("nosuchuserok")
-
-
-      assert(
-        ! user.exists?,
-
-        "Fake user exists?")
-
-    user = mkuser(@me)
-
-      assert(
-        user.exists?,
-
-        "I don't exist?")
-  end
-
-  def attrtest_ensure(user)
-    old = user.ensure
-    assert_nothing_raised {
-      user.delete
-    }
-
-    assert(missing?(user.name), "User is still present")
-    assert_nothing_raised {
-      user.create
-    }
-    assert(!missing?(user.name), "User is absent")
-    assert_nothing_raised {
-      user.delete
-    }
-
-    unless old == :absent
-      user.create
-    end
-  end
-
-  def attrtest_comment(user)
-    old = user.comment
-
-    newname = "Billy O'Neal" # use a single quote, a la #372
-    assert_nothing_raised {
-      user.comment = newname
-    }
-
-
-      assert_equal(
-        newname, current?(:comment, user),
-
-      "Comment was not changed")
-
-    assert_nothing_raised {
-      user.comment = old
-    }
-
-
-      assert_equal(
-        old, current?(:comment, user),
-
-      "Comment was not reverted")
-  end
-
-  def attrtest_home(user)
-    old = current?(:home, user)
-
-    assert_nothing_raised {
-      user.home = "/tmp"
-    }
-
-    assert_equal("/tmp", current?(:home, user), "Home was not changed")
-    assert_nothing_raised {
-      user.home = old
-    }
-
-    assert_equal(old, current?(:home, user), "Home was not reverted")
-  end
-
-  def attrtest_shell(user)
-    old = current?(:shell, user)
-
-    newshell = findshell(old)
-
-    unless newshell
-      $stderr.puts "Cannot find alternate shell; skipping shell test"
-      return
-    end
-
-    assert_nothing_raised {
-      user.shell = newshell
-    }
-
-
-      assert_equal(
-        newshell, current?(:shell, user),
-
-      "Shell was not changed")
-
-    assert_nothing_raised {
-      user.shell = old
-    }
-
-    assert_equal(old, current?(:shell, user), "Shell was not reverted")
-  end
-
-  def attrtest_gid(user)
-    old = current?(:gid, user)
-
-    newgroup = %w{nogroup nobody staff users daemon}.find { |gid|
-      begin
-        group = Etc.getgrnam(gid)
-        rescue ArgumentError => detail
-          next
-        end
-        old != group.gid
-    }
-    group = Etc.getgrnam(newgroup)
-
-    unless newgroup
-      $stderr.puts "Cannot find alternate group; skipping gid test"
-      return
-    end
-
-    # Stupid DirectoryServices
-    if Facter.value(:operatingsystem) == "Darwin"
-      assert_raise(ArgumentError, "gid allowed a non-integer value") do
-        user.gid = group.name
-      end
-    end
-
-    assert_nothing_raised("Failed to specify group by id") {
-      user.gid = group.gid
-    }
-
-    assert_equal(group.gid, current?(:gid,user), "GID was not changed")
-
-    assert_nothing_raised("Failed to change back to old gid") {
-      user.gid = old
-    }
-  end
-
-  def attrtest_uid(user)
-    old = current?(:uid, user)
-
-    newuid = old
-    while true
-      newuid += 1
-
-      if newuid - old > 1000
-        $stderr.puts "Could not find extra test UID"
-        return
-      end
-      begin
-        newuser = Etc.getpwuid(newuid)
-      rescue ArgumentError => detail
-        break
-      end
-    end
-
-    assert_nothing_raised("Failed to change user id") {
-      user.uid = newuid
-    }
-
-    assert_equal(newuid, current?(:uid, user), "UID was not changed")
-
-    assert_nothing_raised("Failed to change user id") {
-      user.uid = old
-    }
-    assert_equal(old, current?(:uid, user), "UID was not changed back")
-  end
-
-  def attrtest_groups(user)
-    Etc.setgrent
-    max = 0
-    while group = Etc.getgrent
-      max = group.gid if group.gid > max and group.gid < 5000
-    end
-
-    groups = []
-    main = []
-    extra = []
-    5.times do |i|
-      i += 1
-      name = "pptstgr#{i}"
-
-        tmpgroup = Puppet::Type.type(:group).new(
-
-          :name => name,
-
-          :gid => max + i
-      )
-
-      groups << tmpgroup
-
-      cleanup do
-        tmpgroup.provider.delete if tmpgroup.provider.exists?
-      end
-
-      if i < 3
-        main << name
-      else
-        extra << name
-      end
-    end
-
-    # Create our test groups
-    assert_apply(*groups)
-
-    # Now add some of them to our user
-    assert_nothing_raised {
-      user.resource[:groups] = extra.join(",")
-    }
-
-    # Some tests to verify that groups work correctly startig from nothing
-    # Remove our user
-    user.delete
-
-    # And add it again
-    user.create
-
-    # Make sure that the group list is added at creation time.
-    # This is necessary because we don't have default fakedata for groups.
-    assert(user.groups, "Did not retrieve group list")
-
-    list = user.groups.split(",")
-    assert_equal(extra.sort, list.sort, "Group list was not set at creation time")
-
-    # Now set to our main list of groups
-    assert_nothing_raised {
-      user.groups = main.join(",")
-    }
-
-    list = user.groups.split(",")
-    assert_equal(main.sort, list.sort, "Group list is not equal")
-  end
-
-  if Puppet.features.root?
-    def test_simpleuser
-      name = "pptest"
-
-      assert(missing?(name), "User #{name} is present")
-
-      user = mkuser(name)
-
-      eachproperty do |property|
-        if val = fakedata(user.name, property)
-          user.resource[property] = val
-        end
-      end
-
-      @@tmpusers << name
-
-      assert_nothing_raised {
-        user.create
-      }
-
-      assert_equal("Puppet's Testing User pptest",
-        user.comment,
-        "Comment was not set")
-
-      assert_nothing_raised {
-        user.delete
-      }
-
-      assert(missing?(user.name), "User was not deleted")
-    end
-
-    def test_alluserproperties
-      user = nil
-      name = "pptest"
-
-      assert(missing?(name), "User #{name} is present")
-
-      user = mkuser(name)
-
-      eachproperty do |property|
-        if val = fakedata(user.name, property)
-          user.resource[property] = val
-        end
-      end
-
-      @@tmpusers << name
-
-      assert_nothing_raised {
-        user.create
-      }
-      assert_equal("Puppet's Testing User pptest", user.comment,
-        "Comment was not set")
-
-      tests = Puppet::Type.type(:user).validproperties
-
-      just = nil
-      tests.each { |test|
-        if self.respond_to?("attrtest_#{test}")
-          self.send("attrtest_#{test}", user)
-        else
-          Puppet.err "Not testing attr #{test} of user"
-        end
-      }
-
-      assert_nothing_raised {
-        user.delete
-      }
-    end
-
-    # This is a weird method that shows how annoying the interface between
-    # types and providers is.  Grr.
-    def test_duplicateIDs
-      user1 = mkuser("user1")
-      user1.create
-      user1.uid = 125
-      user2 = mkuser("user2")
-      user2.resource[:uid] = 125
-
-      cleanup do
-        user1.delete
-        user2.delete
-      end
-
-      # 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.
-      assert_nothing_raised {
-        user2.resource[:allowdupe] = :true
-      }
-      assert_nothing_raised { user2.create }
-
-        assert_equal(
-          :present, user2.ensure,
-
-            "User did not get created")
-    end
-  else
-    $stderr.puts "Not root; skipping user creation/modification tests"
-  end
-
-  # Here is where we test individual providers
-  def test_useradd_flags
-    useradd = nil
-    assert_nothing_raised {
-      useradd = Puppet::Type.type(:user).provider(:useradd)
-    }
-    assert(useradd, "Did not retrieve useradd provider")
-
-    user = nil
-    assert_nothing_raised {
-      fakeresource = fakeresource(:user, @me)
-      user = useradd.new(fakeresource)
-    }
-
-
-      assert_equal(
-        "-d", user.send(:flag, :home),
-
-          "Incorrect home flag")
-
-
-          assert_equal(
-            "-s", user.send(:flag, :shell),
-
-          "Incorrect shell flag")
-  end
-
-  def test_autogen
-    provider = nil
-    user = Puppet::Type.type(:user).new(:name => nonrootuser.name)
-    provider = user.provider
-    assert(provider, "did not get provider")
-
-    # Everyone should be able to autogenerate a uid
-    assert_instance_of(Fixnum, provider.autogen(:uid))
-
-    # If we're Darwin, then we should get results, but everyone else should
-    # get nil
-    darwin = (Facter.value(:operatingsystem) == "Darwin")
-
-    should = {
-      :comment => user[:name].capitalize,
-      :home => "/var/empty",
-      :shell => "/usr/bin/false"
-    }
-
-    should.each do |param, value|
-      if darwin
-        assert_equal(value, provider.autogen(param), "did not autogen #{param} for darwin correctly")
-      else
-        assert_nil(provider.autogen(param), "autogenned #{param} for non-darwin os")
-      end
-    end
-  end
-end
-