puppet 2.7.19 → 2.7.20.rc1

data/spec/unit/provider/service/windows_spec.rb

@@ -114,6 +114,25 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
     end
   end
 
+  describe "#restart" do
+    it "should use the supplied restart command if specified" do
+      resource[:restart] = 'c:/bin/foo'
+
+      provider.expects(:execute).never
+      provider.expects(:execute).with(['c:/bin/foo'], :failonfail => true, :squelch => true)
+
+      provider.restart
+    end
+
+    it "should restart the service" do
+      seq = sequence("restarting")
+      provider.expects(:stop).in_sequence(seq)
+      provider.expects(:start).in_sequence(seq)
+
+      provider.restart
+    end
+  end
+
   describe "#enabled?" do
     it "should report a service with a startup type of manual as manual" do
       config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)

data/spec/unit/provider/user/ldap_spec.rb

@@ -24,14 +24,6 @@ describe provider_class do
     provider_class.should be_manages_passwords
   end
 
-  it "should use the ldap group provider to convert group names to numbers" do
-    provider = provider_class.new(:name => "foo")
-    Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with("bar").returns 10
-
-    provider.gid = 'bar'
-    provider.gid.should == 10
-  end
-
   {:name => "uid",
     :password => "userPassword",
     :comment => "cn",
@@ -53,10 +45,13 @@ describe provider_class do
     end
 
     it "should generate the sn as the last field of the cn" do
+      Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
+
       resource = stub 'resource', :should => %w{whatever}
       resource.stubs(:should).with(:comment).returns ["Luke Kanies"]
       resource.stubs(:should).with(:ensure).returns :present
       instance = provider_class.new(:name => "luke", :ensure => :absent)
+
       instance.stubs(:resource).returns resource
 
       @connection.expects(:add).with { |dn, attrs| attrs["sn"] == ["Kanies"] }
@@ -65,8 +60,25 @@ describe provider_class do
       instance.flush
     end
 
+    it "should translate a group name to the numeric id" do
+      Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with("bar").returns 101
+
+      resource = stub 'resource', :should => %w{whatever}
+      resource.stubs(:should).with(:gid).returns 'bar'
+      resource.stubs(:should).with(:ensure).returns :present
+      instance = provider_class.new(:name => "luke", :ensure => :absent)
+      instance.stubs(:resource).returns resource
+
+      @connection.expects(:add).with { |dn, attrs| attrs["gidNumber"] == ["101"] }
+
+      instance.create
+      instance.flush
+    end
+
     describe "with no uid specified" do
       it "should pick the first available UID after the largest existing UID" do
+        Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
+
         low = {:name=>["luke"], :shell=>:absent, :uid=>["600"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["l k"]}
         high = {:name=>["testing"], :shell=>:absent, :uid=>["640"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["t u"]}
         provider_class.manager.expects(:search).returns([low, high])
@@ -84,6 +96,8 @@ describe provider_class do
       end
 
       it "should pick 501 of no users exist" do
+        Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with(["whatever"]).returns [123]
+
         provider_class.manager.expects(:search).returns nil
 
         resource = stub 'resource', :should => %w{whatever}

data/spec/unit/provider/user/user_role_add_spec.rb

@@ -300,4 +300,16 @@ FIXTURE
       @provider.shadow_entry.should == ["fakeval", "*", "20", "10", "30", "7", "2"]
     end
   end
+
+  describe "#password_max_age" do
+    it "should return a maximum age number" do
+      File.stubs(:readlines).returns(["fakeval:NP:12345:0:50::::\n"])
+      @provider.password_max_age.should == "50"
+    end
+
+    it "should return -1 for no maximum" do
+      File.stubs(:readlines).returns(["fakeval:NP:12345::::::\n"])
+      @provider.password_max_age.should == -1
+    end
+  end
 end

data/spec/unit/provider/user/useradd_spec.rb

@@ -1,111 +1,140 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:user).provider(:useradd)
-
-describe provider_class do
-  before do
-    @resource = stub("resource", :name => "myuser", :managehome? => nil)
-    @resource.stubs(:should).returns "fakeval"
-    @resource.stubs(:[]).returns "fakeval"
-    @provider = provider_class.new(@resource)
+describe Puppet::Type.type(:user).provider(:useradd) do
+
+  before :each do
+    described_class.stubs(:command).with(:password).returns '/usr/bin/chage'
+    described_class.stubs(:command).with(:add).returns '/usr/sbin/useradd'
+    described_class.stubs(:command).with(:modify).returns '/usr/sbin/usermod'
+    described_class.stubs(:command).with(:delete).returns '/usr/sbin/userdel'
   end
 
-  # #1360
-  it "should add -o when allowdupe is enabled and the user is being created" do
-    @resource.expects(:allowdupe?).returns true
-    @resource.expects(:system?).returns true
-    @provider.stubs(:execute)
-    @provider.expects(:execute).with { |args| args.include?("-o") }
-    @provider.create
+  let(:resource) do
+    Puppet::Type.type(:user).new(
+      :name       => 'myuser',
+      :managehome => :false,
+      :system     => :false,
+      :provider   => provider
+    )
   end
 
-  it "should add -o when allowdupe is enabled and the uid is being modified" do
-    @resource.expects(:allowdupe?).returns true
-    @provider.expects(:execute).with { |args| args.include?("-o") }
+  let(:provider) { described_class.new(:name => 'myuser') }
 
-    @provider.uid = 150
-  end
+  describe "#create" do
+
+    it "should add -o when allowdupe is enabled and the user is being created" do
+      resource[:allowdupe] = true
+      provider.expects(:execute).with(['/usr/sbin/useradd', '-o', 'myuser'])
+      provider.create
+    end
+
+    describe "on systems that support has_system", :if => described_class.system_users? do
+      it "should add -r when system is enabled" do
+        resource[:system] = :true
+        provider.should be_system_users
+        provider.expects(:execute).with(['/usr/sbin/useradd', '-r', 'myuser'])
+        provider.create
+      end
+    end
+
+    describe "on systems that do not support has_system", :unless => described_class.system_users? do
+      it "should not add -r when system is enabled" do
+        resource[:system] = :true
+        provider.should_not be_system_users
+        provider.expects(:execute).with(['/usr/sbin/useradd', 'myuser'])
+        provider.create
+      end
+    end
 
-  it "should add -r when system is enabled" do
-    @resource.expects(:allowdupe?).returns true
-    @resource.expects(:system?).returns true
-    @provider.stubs(:execute)
-    @provider.expects(:execute).with { |args| args.include?("-r") }
-    @provider.create
+    it "should set password age rules" do
+      described_class.has_feature :manages_password_age
+      resource[:password_min_age] = 5
+      resource[:password_max_age] = 10
+      provider.expects(:execute).with(['/usr/sbin/useradd', 'myuser'])
+      provider.expects(:execute).with(['/usr/bin/chage', '-m', 5, '-M', 10, 'myuser'])
+      provider.create
+    end
   end
 
-  it "should set password age rules" do
-    provider_class.has_feature :manages_password_age
-    @resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :provider => :useradd
-    @provider = provider_class.new(@resource)
-    @provider.stubs(:execute)
-    @provider.expects(:execute).with { |cmd, *args| args == ["-m", 5, "-M", 10, "myuser"] }
-    @provider.create
+  describe "#uid=" do
+    it "should add -o when allowdupe is enabled and the uid is being modified" do
+      resource[:allowdupe] = :true
+      provider.expects(:execute).with(['/usr/sbin/usermod', '-u', 150, '-o', 'myuser'])
+      provider.uid = 150
+    end
   end
 
-  describe "when checking to add allow dup" do
+  describe "#check_allow_dup" do
     it "should check allow dup" do
-      @resource.expects(:allowdupe?)
-      @provider.check_allow_dup
+      resource.expects(:allowdupe?)
+      provider.check_allow_dup
     end
 
     it "should return an array with a flag if dup is allowed" do
-      @resource.stubs(:allowdupe?).returns true
-      @provider.check_allow_dup.must == ["-o"]
+      resource[:allowdupe] = :true
+      provider.check_allow_dup.must == ["-o"]
     end
 
     it "should return an empty array if no dup is allowed" do
-      @resource.stubs(:allowdupe?).returns false
-      @provider.check_allow_dup.must == []
+      resource[:allowdupe] = :false
+      provider.check_allow_dup.must == []
     end
   end
 
-  describe "when checking to add system users" do
+  describe "#check_system_users" do
     it "should check system users" do
-      @resource.expects(:system?)
-      @provider.check_system_users
+      described_class.expects(:system_users?).returns true
+      resource.expects(:system?)
+      provider.check_system_users
     end
 
     it "should return an array with a flag if it's a system user" do
-      @resource.stubs(:system?).returns true
-      @provider.check_system_users.must == ["-r"]
+      described_class.expects(:system_users?).returns true
+      resource[:system] = :true
+      provider.check_system_users.must == ["-r"]
     end
 
     it "should return an empty array if it's not a system user" do
-      @resource.stubs(:system?).returns false
-      @provider.check_system_users.must == []
+      described_class.expects(:system_users?).returns true
+      resource[:system] = :false
+      provider.check_system_users.must == []
+    end
+
+    it "should return an empty array if system user is not featured" do
+      described_class.expects(:system_users?).returns false
+      resource[:system] = :true
+      provider.check_system_users.must == []
     end
   end
 
-  describe "when checking manage home" do
+  describe "#check_manage_home" do
     it "should check manage home" do
-      @resource.expects(:managehome?)
-      @provider.check_manage_home
+      resource.expects(:managehome?)
+      provider.check_manage_home
     end
 
     it "should return an array with -m flag if home is managed" do
-      @resource.stubs(:managehome?).returns true
-      @provider.check_manage_home.must == ["-m"]
+      resource[:managehome] = :true
+      provider.check_manage_home.must == ["-m"]
     end
-    
+
     it "should return an array with -r flag if home is managed" do
-      @resource.stubs(:managehome?).returns true
-      @resource.stubs(:ensure) == :absent
-      @provider.stubs(:command).returns("userdel")
-      @provider.deletecmd.must == ["userdel", "-r", "fakeval"]
+      resource[:managehome] = :true
+      resource[:ensure] = :absent
+      provider.deletecmd.must == ['/usr/sbin/userdel', '-r', 'myuser']
     end
 
     it "should return an array with -M if home is not managed and on Redhat" do
-      Facter.stubs(:value).with("operatingsystem").returns("RedHat")
-      @resource.stubs(:managehome?).returns false
-      @provider.check_manage_home.must == ["-M"]
+      Facter.stubs(:value).with(:operatingsystem).returns("RedHat")
+      resource[:managehome] = :false
+      provider.check_manage_home.must == ["-M"]
     end
 
     it "should return an empty array if home is not managed and not on Redhat" do
-      Facter.stubs(:value).with("operatingsystem").returns("some OS")
-      @resource.stubs(:managehome?).returns false
-      @provider.check_manage_home.must == []
+      Facter.stubs(:value).with(:operatingsystem).returns("some OS")
+      resource[:managehome] = :false
+      provider.check_manage_home.must == []
     end
   end
 
@@ -116,107 +145,106 @@ describe provider_class do
     it "should return and array of flags and values"
   end
 
-  describe "when calling addcmd" do
+  describe "#addcmd" do
     before do
-      @resource.stubs(:allowdupe?).returns true
-      @resource.stubs(:managehome?).returns true
-      @resource.stubs(:system?).returns true
+      resource[:allowdupe] = :true
+      resource[:managehome] = :true
+      resource[:system] = :true
     end
 
     it "should call command with :add" do
-      @provider.expects(:command).with(:add)
-      @provider.addcmd
+      provider.expects(:command).with(:add)
+      provider.addcmd
     end
 
     it "should add properties" do
-      @provider.expects(:add_properties).returns([])
-      @provider.addcmd
+      provider.expects(:add_properties).returns(['-foo_add_properties'])
+      provider.addcmd.should include '-foo_add_properties'
     end
 
     it "should check and add if dup allowed" do
-      @provider.expects(:check_allow_dup).returns([])
-      @provider.addcmd
+      provider.expects(:check_allow_dup).returns(['-allow_dup_flag'])
+      provider.addcmd.should include '-allow_dup_flag'
     end
 
     it "should check and add if home is managed" do
-      @provider.expects(:check_manage_home).returns([])
-      @provider.addcmd
+      provider.expects(:check_manage_home).returns(['-manage_home_flag'])
+      provider.addcmd.should include '-manage_home_flag'
     end
 
     it "should add the resource :name" do
-      @resource.expects(:[]).with(:name)
-      @provider.addcmd
+      provider.addcmd.should include 'myuser'
     end
 
-    it "should return an array with -r if system? is true" do
-      resource = Puppet::Type.type(:user).new( :name => "bob", :system => true)
+    describe "on systems featuring system_users", :if => described_class.system_users? do
+      it "should return an array with -r if system? is true" do
+        resource[:system] = :true
+        provider.addcmd.should include("-r")
+      end
 
-      provider_class.new( resource ).addcmd.should include("-r")
+      it "should return an array without -r if system? is false" do
+        resource[:system] = :false
+        provider.addcmd.should_not include("-r")
+      end
     end
 
-    it "should return an array without -r if system? is false" do
-      resource = Puppet::Type.type(:user).new( :name => "bob", :system => false)
-
-      provider_class.new( resource ).addcmd.should_not include("-r")
+    describe "on systems not featuring system_users", :unless => described_class.system_users? do
+      [:false, :true].each do |system|
+        it "should return an array without -r if system? is #{system}" do
+          resource[:system] = system
+          provider.addcmd.should_not include("-r")
+        end
+      end
     end
 
     it "should return an array with full command" do
-      @provider.stubs(:command).with(:add).returns("useradd")
-      @provider.stubs(:add_properties).returns(["-G", "somegroup"])
-      @resource.stubs(:[]).with(:name).returns("someuser")
-      @resource.stubs(:[]).with(:expiry).returns("somedate")
-      @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", '-e somedate', "-r", "someuser"]
+      described_class.expects(:system_users?).returns true
+      provider.stubs(:add_properties).returns(["-G", "somegroup"])
+      resource[:expiry] = "2012-08-18"
+
+      provider.addcmd.must == ["/usr/sbin/useradd", "-G", "somegroup", "-o", "-m", '-e 2012-08-18', "-r", "myuser"]
     end
 
     it "should return an array without -e if expiry is undefined full command" do
-      @provider.stubs(:command).with(:add).returns("useradd")
-      @provider.stubs(:add_properties).returns(["-G", "somegroup"])
-      @resource.stubs(:[]).with(:name).returns("someuser")
-      @resource.stubs(:[]).with(:expiry).returns nil
-      @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", "-r", "someuser"]
+      described_class.expects(:system_users?).returns true
+      provider.stubs(:add_properties).returns(["-G", "somegroup"])
+      provider.addcmd.must == ["/usr/sbin/useradd", "-G", "somegroup", "-o", "-m", "-r", "myuser"]
     end
   end
 
-  describe "when calling passcmd" do
+  describe "#passcmd" do
     before do
-      @resource.stubs(:allowdupe?).returns true
-      @resource.stubs(:managehome?).returns true
-      @resource.stubs(:system?).returns true
+      resource[:allowdupe] = :true
+      resource[:managehome] = :true
+      resource[:system] = :true
     end
 
     it "should call command with :pass" do
-      @provider.expects(:command).with(:password)
-      @provider.passcmd
+      # command(:password) is only called inside passcmd if
+      # password_min_age or password_max_age is set
+      resource[:password_min_age] = 123
+      provider.expects(:command).with(:password)
+      provider.passcmd
     end
 
     it "should return nil if neither min nor max is set" do
-      @resource.stubs(:should).with(:password_min_age).returns nil
-      @resource.stubs(:should).with(:password_max_age).returns nil
-      @provider.passcmd.must == nil
+      provider.passcmd.must be_nil
     end
 
     it "should return a chage command array with -m <value> and the user name if password_min_age is set" do
-      @provider.stubs(:command).with(:password).returns("chage")
-      @resource.stubs(:[]).with(:name).returns("someuser")
-      @resource.stubs(:should).with(:password_min_age).returns 123
-      @resource.stubs(:should).with(:password_max_age).returns nil
-      @provider.passcmd.must == ['chage','-m',123,'someuser']
+      resource[:password_min_age] = 123
+      provider.passcmd.must == ['/usr/bin/chage','-m',123,'myuser']
     end
 
     it "should return a chage command array with -M <value> if password_max_age is set" do
-      @provider.stubs(:command).with(:password).returns("chage")
-      @resource.stubs(:[]).with(:name).returns("someuser")
-      @resource.stubs(:should).with(:password_min_age).returns nil
-      @resource.stubs(:should).with(:password_max_age).returns 999
-      @provider.passcmd.must == ['chage','-M',999,'someuser']
+      resource[:password_max_age] = 999
+      provider.passcmd.must == ['/usr/bin/chage','-M',999,'myuser']
     end
 
     it "should return a chage command array with -M <value> -m <value> if both password_min_age and password_max_age are set" do
-      @provider.stubs(:command).with(:password).returns("chage")
-      @resource.stubs(:[]).with(:name).returns("someuser")
-      @resource.stubs(:should).with(:password_min_age).returns 123
-      @resource.stubs(:should).with(:password_max_age).returns 999
-      @provider.passcmd.must == ['chage','-m',123,'-M',999,'someuser']
+      resource[:password_min_age] = 123
+      resource[:password_max_age] = 999
+      provider.passcmd.must == ['/usr/bin/chage','-m',123,'-M',999,'myuser']
     end
   end
 end