puppet 2.7.26 → 3.0.0.rc4

data/test/ral/providers/user/useradd.rb

@@ -1,233 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../../lib/puppettest')
-
-require 'mocha'
-
-class UserAddProviderTest < PuppetTest::TestCase
-  confine "useradd user provider missing" =>
-    Puppet::Type.type(:user).provider(:useradd).suitable?
-
-  def setup
-    super
-    @type = Puppet::Type.type(:user)
-    @provider = Puppet::Type.type(:user).provider(:useradd)
-    @home = tempfile
-    @vals = {:name => 'faff',
-      :provider => :useradd,
-      :ensure => :present,
-      :uid => 5000,
-      :gid => 5000,
-      :home => @home,
-      :comment => "yayness",
-      :groups => %w{one two}
-    }
-  end
-
-  def setup_user
-    @user = @type.new(@vals)
-
-    @vals.each do |name, val|
-      next unless @user.class.validproperty?(name)
-    end
-    @user
-  end
-
-  def test_features
-    [:manages_homedir].each do |feature|
-
-            assert(
-        @provider.feature?(feature),
-        
-        "useradd provider is missing #{feature}")
-    end
-  end
-
-  def test_create
-    user = setup_user
-
-    @vals.each do |name, val|
-      next unless user.class.validproperty?(name)
-    end
-
-    user.expects(:allowdupe?).returns(false)
-    user.expects(:managehome?).returns(false)
-
-    user.provider.expects(:execute).with do |params|
-      command = params.shift
-      assert_equal(@provider.command(:add), command,
-        "Got incorrect command")
-
-      if %w{Fedora RedHat}.include?(Facter.value(:operatingsystem))
-        assert(params.include?("-M"), "Did not disable homedir creation on red hat")
-        params.delete("-M")
-      end
-
-      options = {}
-      options[params.shift] = params.shift while params.length > 0
-
-      @vals[:groups] = @vals[:groups].join(",")
-
-      flags = {:home => "-d", :groups => "-G", :gid => "-g",
-        :uid => "-u", :comment => "-c"}
-
-      flags.each do |param, flag|
-        assert_equal(@vals[param], options[flag], "Got incorrect value for #{param}")
-      end
-
-      true
-    end
-
-    user.provider.create
-  end
-
-  # Make sure we add the right flags when managing home
-  def test_managehome
-    @vals[:managehome] = true
-    setup_user
-
-
-          assert(
-        @user.provider.respond_to?(:manages_homedir?),
-        
-      "provider did not get managehome test set")
-
-    assert(@user.managehome?, "provider did not get managehome")
-
-    # First run
-    @user.expects(:managehome?).returns(true)
-
-    @user.provider.expects(:execute).with do |params|
-      assert_equal(params[0], @provider.command(:add), "useradd was not called")
-      assert(params.include?("-m"), "Did not add -m when managehome was in affect")
-      assert(! params.include?("-M"), "Added -M when managehome was in affect")
-
-      true
-    end
-
-    @user.provider.create
-
-    # Start again, this time with manages_home off
-    @vals[:managehome] = false
-    setup_user
-
-    # First run
-    @user.expects(:managehome?).returns(false)
-
-    @user.provider.expects(:execute).with do |params|
-      assert_equal(params[0], @provider.command(:add), "useradd was not called")
-      assert(params.include?("-M"), "Did not add -M on Red Hat") if %w{Fedora RedHat}.include?(Facter.value(:operatingsystem))
-      assert(! params.include?("-m"), "Added -m when managehome was disabled")
-
-      true
-    end
-
-    @user.provider.create
-  end
-
-  def test_allowdupe
-    @vals[:allowdupe] = true
-    setup_user
-
-
-          assert(
-        @user.provider.respond_to?(:allows_duplicates?),
-        
-      "provider did not get allowdupe test set")
-
-    assert(@user.allowdupe?, "provider did not get allowdupe")
-
-    # First run
-    @user.expects(:allowdupe?).returns(true)
-
-    @user.provider.expects(:execute).with do |params|
-      assert_equal(params[0], @provider.command(:add), "useradd was not called")
-      assert(params.include?("-o"), "Did not add -o when allowdupe was in affect")
-
-      true
-    end
-
-    @user.provider.create
-
-    # Start again, this time with manages_home off
-    @vals[:allowdupe] = false
-    setup_user
-
-    # First run
-    @user.expects(:allowdupe?).returns(false)
-
-    @user.provider.expects(:execute).with do |params|
-      assert_equal(params[0], @provider.command(:add), "useradd was not called")
-      assert(! params.include?("-o"), "Added -o when allowdupe was disabled")
-
-      true
-    end
-
-    @user.provider.create
-  end
-
-  def test_manages_password
-    return unless @provider.feature?(:manages_passwords)
-    @vals[:password] = "somethingorother"
-    setup_user
-
-    @user.provider.expects(:execute).with do |params|
-      assert_equal(params[0], @provider.command(:add), "useradd was not called")
-      params.shift
-      options = {}
-      params.each_with_index do |p, i|
-        if p =~ /^-/ and p != "-M"
-          options[p] = params[i + 1]
-        end
-      end
-      assert_equal(options["-p"], @vals[:password], "Did not set password in useradd call")
-      true
-    end
-
-    @user.provider.create
-
-    # Now mark the user made, and make sure the right command is called
-    setup_user
-    @vals[:password] = "somethingelse"
-
-    @user.provider.expects(:execute).with do |params|
-      assert_equal(params[0], @provider.command(:modify), "usermod was not called")
-
-      options = {}
-      params.each_with_index do |p, i|
-        if p =~ /^-/ and p != "-M"
-          options[p] = params[i + 1]
-        end
-      end
-
-            assert_equal(
-        options["-p"], @vals[:password],
-        
-        "Did not set password in useradd call")
-      true
-    end
-
-    @user.provider.password = @vals[:password]
-  end
-
-end
-
-class UserRootAddProviderTest < PuppetTest::TestCase
-  confine "useradd user provider missing" => Puppet::Type.type(:user).provider(:useradd).suitable?
-  confine "useradd does not manage passwords" => Puppet::Type.type(:user).provider(:useradd).manages_passwords?
-  confine "not running as root" => (Process.uid == 0)
-
-  def test_password
-    user = Puppet::Type.type(:user).new(:name => "root", :check => [:password], :provider => :useradd)
-
-    provider = user.provider
-
-    assert_nothing_raised("Could not check password") do
-      pass = provider.password
-      assert(pass, "Did not get password for root")
-      assert(pass!= "x", "Password was retrieved from /etc/passwd instead of /etc/shadow")
-    end
-  end
-end
-
-

data/test/ral/type/cron.rb

@@ -1,505 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path(File.dirname(__FILE__) + '/../../lib/puppettest')
-
-require 'puppettest'
-
-# Test cron job creation, modification, and destruction
-
-class TestCron < Test::Unit::TestCase
-  include PuppetTest
-
-  def setup
-    super
-
-    setme
-
-    @crontype = Puppet::Type.type(:cron)
-    @provider = @crontype.defaultprovider
-    if @provider.respond_to?(:filetype=)
-      @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-    end
-    @crontype = Puppet::Type.type(:cron)
-  end
-
-  def teardown
-    super
-    @crontype.defaultprovider = nil
-  end
-
-  def eachprovider
-    @crontype.suitableprovider.each do |provider|
-      yield provider
-    end
-  end
-
-  # Back up the user's existing cron tab if they have one.
-  def cronback
-    tab = nil
-    assert_nothing_raised {
-      tab = Puppet::Type.type(:cron).filetype.read(@me)
-    }
-
-    @currenttab = $CHILD_STATUS == 0 ? tab : nil
-  end
-
-  # Restore the cron tab to its original form.
-  def cronrestore
-    assert_nothing_raised {
-      if @currenttab
-        @crontype.filetype.new(@me).write(@currenttab)
-      else
-        @crontype.filetype.new(@me).remove
-      end
-    }
-  end
-
-  # Create a cron job with all fields filled in.
-  def mkcron(name, addargs = true)
-    cron = nil
-    command = "date > #{tmpdir()}/crontest#{name}"
-    args = nil
-    if addargs
-      args = {
-        :command => command,
-        :name => name,
-        :user => @me,
-        :minute => rand(59),
-        :month => "1",
-        :monthday => "1",
-        :hour => "1"
-      }
-    else
-      args = {:command => command, :name => name}
-    end
-    assert_nothing_raised {
-      cron = @crontype.new(args)
-    }
-
-    cron
-  end
-
-  # Run the cron through its paces -- install it then remove it.
-  def cyclecron(cron)
-    obj = Puppet::Type::Cron.cronobj(@me)
-
-    text = obj.read
-    name = cron.name
-    comp = mk_catalog(name, cron)
-
-    assert_events([:cron_created], comp)
-    cron.provider.class.prefetch
-    currentvalue = cron.retrieve
-
-    assert(cron.insync?(currentvalue), "Cron is not in sync")
-
-    assert_events([], comp)
-
-    curtext = obj.read
-    text.split("\n").each do |line|
-      assert(curtext.include?(line), "Missing '#{line}'")
-    end
-    obj = Puppet::Type::Cron.cronobj(@me)
-
-    cron[:ensure] = :absent
-
-    assert_events([:cron_removed], comp)
-
-    cron.provider.class.prefetch
-    currentvalue = cron.retrieve
-
-    assert(cron.insync?(currentvalue), "Cron is not in sync")
-    assert_events([], comp)
-  end
-
-  # Test that a cron job with spaces at the end doesn't get rewritten
-  def test_trailingspaces
-    eachprovider do |provider|
-      cron = nil
-      # make the cron
-      name = "yaytest"
-      command = "date > /dev/null "
-      assert_nothing_raised {
-
-        cron = @crontype.new(
-
-          :name => name,
-          :command => "date > /dev/null ",
-          :month => "May",
-
-          :user => @me
-        )
-      }
-      property = cron.send(:property, :command)
-      cron.provider.command = command
-      cron.provider.ensure = :present
-      cron.provider.user = @me
-      cron.provider.month = ["4"]
-      cron.provider.class.prefetch
-      currentvalue = cron.retrieve
-      assert(cron.parameter(:command).insync?(currentvalue[:command]), "Property :command is not considered in sync with value #{currentvalue[:command]}")
-    end
-  end
-
-  def test_makeandretrievecron
-    %w{storeandretrieve a-name another-name more_naming SomeName}.each do |name|
-      cron = mkcron(name)
-      catalog = mk_catalog(name, cron)
-      trans = assert_events([:cron_created], catalog, name)
-
-      cron.provider.class.prefetch
-      cron = nil
-
-      assert(cron = catalog.resource(:cron, name), "Could not retrieve named cron")
-      assert_instance_of(Puppet::Type.type(:cron), cron)
-    end
-  end
-
-  # Do input validation testing on all of the parameters.
-  def test_arguments
-    values = {
-      :monthday => {
-        :valid => [ 1, 13, "1" ],
-        :invalid => [ -1, 0, 32 ]
-      },
-      :weekday => {
-        :valid => [ 0, 3, 6, "1", "tue", "wed",
-          "Wed", "MOnday", "SaTurday" ],
-        :invalid => [ -1, 8, "13", "tues", "teusday", "thurs" ]
-      },
-      :hour => {
-        :valid => [ 0, 21, 23 ],
-        :invalid => [ -1, 24 ]
-      },
-      :minute => {
-        :valid => [ 0, 34, 59 ],
-        :invalid => [ -1, 60 ]
-      },
-      :month => {
-        :valid => [ 1, 11, 12, "mar", "March", "apr", "October", "DeCeMbEr" ],
-        :invalid => [ -1, 0, 13, "marc", "sept" ]
-      }
-    }
-
-    cron = mkcron("valtesting")
-    values.each { |param, hash|
-      # We have to test the valid ones first, because otherwise the
-      # property will fail to create at all.
-      [:valid, :invalid].each { |type|
-        hash[type].each { |value|
-          case type
-          when :valid
-            assert_nothing_raised {
-              cron[param] = value
-            }
-
-            assert_equal([value.to_s], cron.should(param), "Cron value was not set correctly") if value.is_a?(Integer)
-          when :invalid
-            assert_raise(Puppet::Error, "#{value} is incorrectly a valid #{param}") {
-              cron[param] = value
-            }
-          end
-
-          if value.is_a?(Integer)
-            value = value.to_s
-            redo
-          end
-        }
-      }
-    }
-  end
-
-  # Verify that comma-separated numbers are not resulting in rewrites
-  def test_comma_separated_vals_work
-    eachprovider do |provider|
-      cron = nil
-      assert_nothing_raised {
-
-        cron = @crontype.new(
-
-          :command => "/bin/date > /dev/null",
-          :minute => [0, 30],
-          :name => "crontest",
-
-          :provider => provider.name
-        )
-      }
-
-
-      cron.provider.ensure = :present
-      cron.provider.command = '/bin/date > /dev/null'
-      cron.provider.minute = %w{0 30}
-      cron.provider.class.prefetch
-      currentvalue = cron.retrieve
-
-      currentvalue.each do |name, value|
-        # We're only interested in comparing minutes.
-        next unless name.to_s == "minute"
-        assert(cron.parameter(name).insync?(value), "Property #{name} is not considered in sync with value #{value.inspect}")
-      end
-    end
-  end
-
-  def test_fieldremoval
-    cron = nil
-    assert_nothing_raised {
-
-      cron = @crontype.new(
-
-        :command => "/bin/date > /dev/null",
-        :minute => [0, 30],
-        :name => "crontest",
-
-        :provider => :crontab
-      )
-    }
-
-    assert_events([:cron_created], cron)
-    cron.provider.class.prefetch
-
-    cron[:minute] = :absent
-    assert_events([:minute_changed], cron)
-
-    current_values = nil
-    assert_nothing_raised {
-      cron.provider.class.prefetch
-      current_values = cron.retrieve
-    }
-    assert_equal(:absent, current_values[cron.property(:minute)])
-  end
-
-  def test_listing
-    # Make a crontab cron for testing
-    provider = @crontype.provider(:crontab)
-    return unless provider.suitable?
-
-    ft = provider.filetype
-    provider.filetype = :ram
-    cleanup { provider.filetype = ft }
-
-    setme
-
-      cron = @crontype.new(
-        :name => "testing",
-      :minute => [0, 30],
-      :command => "/bin/testing",
-
-      :user => @me
-    )
-    # Write it to our file
-    assert_apply(cron)
-
-    crons = []
-    assert_nothing_raised {
-      @crontype.instances.each do |cron|
-        crons << cron
-      end
-    }
-
-    crons.each do |cron|
-      assert_instance_of(@crontype, cron, "Did not receive a real cron object")
-
-        assert_instance_of(
-          String, cron.value(:user),
-
-          "Cron user is not a string")
-    end
-  end
-
-  def verify_failonnouser
-    assert_raise(Puppet::Error) do
-      @crontype.retrieve("nosuchuser")
-    end
-  end
-
-  def test_divisionnumbers
-    cron = mkcron("divtest")
-    cron[:minute] = "*/5"
-
-    assert_apply(cron)
-
-    cron.provider.class.prefetch
-    currentvalue = cron.retrieve
-
-    assert_equal(["*/5"], currentvalue[cron.property(:minute)])
-  end
-
-  def test_ranges
-    cron = mkcron("rangetest")
-    cron[:minute] = "2-4"
-
-    assert_apply(cron)
-
-    current_values = nil
-    assert_nothing_raised {
-      cron.provider.class.prefetch
-      current_values = cron.retrieve
-    }
-
-    assert_equal(["2-4"], current_values[cron.property(:minute)])
-  end
-
-
-  def provider_set(cron, param, value)
-    unless param =~ /=$/
-      param = "#{param}="
-    end
-
-    cron.provider.send(param, value)
-  end
-
-  def test_value
-    cron = mkcron("valuetesting", false)
-
-    # First, test the normal properties
-    [:minute, :hour, :month].each do |param|
-      cron.newattr(param)
-      property = cron.property(param)
-
-      assert(property, "Did not get #{param} property")
-
-      assert_nothing_raised {
-        #                property.is = :absent
-        provider_set(cron, param, :absent)
-      }
-
-      val = "*"
-      assert_equal(val, cron.value(param))
-
-      # Make sure arrays work, too
-      provider_set(cron, param, ["1"])
-      assert_equal(%w{1}, cron.value(param))
-
-      # Make sure values get comma-joined
-      provider_set(cron, param, %w{2 3})
-      assert_equal(%w{2 3}, cron.value(param))
-
-      # Make sure "should" values work, too
-      cron[param] = "4"
-      assert_equal(%w{4}, cron.value(param))
-
-      cron[param] = ["4"]
-      assert_equal(%w{4}, cron.value(param))
-
-      cron[param] = ["4", "5"]
-      assert_equal(%w{4 5}, cron.value(param))
-
-      provider_set(cron, param, :absent)
-      assert_equal(%w{4 5}, cron.value(param))
-    end
-
-    Puppet[:trace] = false
-
-    # Now make sure that :command works correctly
-    cron.delete(:command)
-    cron.newattr(:command)
-    property = cron.property(:command)
-
-    assert_nothing_raised {
-      provider_set(cron, :command, :absent)
-    }
-
-    param = :command
-    # Make sure arrays work, too
-    provider_set(cron, param, ["/bin/echo"])
-    assert_equal("/bin/echo", cron.value(param))
-
-    # Make sure values are not comma-joined
-    provider_set(cron, param, %w{/bin/echo /bin/test})
-    assert_equal("/bin/echo", cron.value(param))
-
-    # Make sure "should" values work, too
-    cron[param] = "/bin/echo"
-    assert_equal("/bin/echo", cron.value(param))
-
-    cron[param] = ["/bin/echo"]
-    assert_equal("/bin/echo", cron.value(param))
-
-    cron[param] = %w{/bin/echo /bin/test}
-    assert_equal("/bin/echo", cron.value(param))
-
-    provider_set(cron, param, :absent)
-    assert_equal("/bin/echo", cron.value(param))
-  end
-
-  def test_multiple_users
-    crons = []
-    users = ["root", nonrootuser.name]
-    users.each do |user|
-
-      cron = Puppet::Type.type(:cron).new(
-
-        :name => "testcron-#{user}",
-        :user => user,
-        :command => "/bin/echo",
-
-        :minute => [0,30]
-      )
-      crons << cron
-
-      assert_equal(cron.should(:user), cron.should(:target),
-        "Target was not set correctly for #{user}")
-    end
-    provider = crons[0].provider.class
-
-    assert_apply(*crons)
-
-    users.each do |user|
-      users.each do |other|
-        next if user == other
-        text = provider.target_object(other).read
-
-
-          assert(
-            text !~ /testcron-#{user}/,
-
-            "#{user}'s cron job is in #{other}'s tab")
-      end
-    end
-  end
-
-  # Make sure the user stuff defaults correctly.
-  def test_default_user
-    crontab = @crontype.provider(:crontab)
-    if crontab.suitable?
-
-      inst = @crontype.new(
-
-        :name => "something", :command => "/some/thing",
-
-        :provider => :crontab)
-      assert_equal(Etc.getpwuid(Process.uid).name, inst.should(:user), "user did not default to current user with crontab")
-      assert_equal(Etc.getpwuid(Process.uid).name, inst.should(:target), "target did not default to current user with crontab")
-
-      # Now make a new cron with a user, and make sure it gets copied
-      # over
-
-        inst = @crontype.new(
-          :name => "yay", :command => "/some/thing",
-
-          :user => "bin", :provider => :crontab)
-
-            assert_equal(
-              "bin", inst.should(:target),
-
-              "target did not default to user with crontab")
-    end
-  end
-
-  # #705 - make sure extra spaces don't screw things up
-  def test_spaces_in_command
-    string = "echo   multiple  spaces"
-    cron = @crontype.new(:name => "space testing", :command => string)
-    assert_apply(cron)
-
-    cron = @crontype.new(:name => "space testing", :command => string)
-
-    # Now make sure that it's correctly in sync
-    cron.provider.class.prefetch("testing" => cron)
-    properties = cron.retrieve
-    assert_equal(string, properties[:command], "Cron did not pick up extra spaces in command")
-    assert(cron.parameter(:command).insync?(properties[:command]), "Command changed with multiple spaces")
-  end
-end
-
-