puppet 3.0.0.rc5 → 3.0.0.rc7

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

@@ -1,111 +1,140 @@
 #! /usr/bin/env ruby -S 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,107 @@ 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
+      described_class.has_feature :manages_password_age
     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

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

@@ -83,6 +83,17 @@ describe Puppet::Type.type(:user).provider(:windows_adsi) do
       provider.create
     end
 
+    it "should load the profile if managehome is set", :if => Puppet.features.microsoft_windows? do
+      resource[:password] = '0xDeadBeef'
+      resource[:managehome] = true
+
+      user = stub_everything 'user'
+      Puppet::Util::ADSI::User.expects(:create).with('testuser').returns user
+      Puppet::Util::Windows::User.expects(:load_profile).with('testuser', '0xDeadBeef')
+
+      provider.create
+    end
+
     it "should set a user's password" do
       provider.user.expects(:password=).with('plaintextbad')
 
@@ -125,6 +136,17 @@ describe Puppet::Type.type(:user).provider(:windows_adsi) do
     provider.delete
   end
 
+  it 'should delete the profile if managehome is set' do
+    resource[:managehome] = true
+
+    sid = 'S-A-B-C'
+    Puppet::Util::ADSI.expects(:sid_for_account).with('testuser').returns(sid)
+    Puppet::Util::ADSI::UserProfile.expects(:delete).with(sid)
+    connection.expects(:Delete).with('user', 'testuser')
+
+    provider.delete
+  end
+
   it "should commit the user when flushed" do
     provider.user.expects(:commit)
 

data/spec/unit/provider/zone/solaris_spec.rb

@@ -3,13 +3,23 @@ require 'spec_helper'
 
 describe Puppet::Type.type(:zone).provider(:solaris) do
   let(:resource) { Puppet::Type.type(:zone).new(:name => 'dummy', :path => '/', :provider => :solaris) }
-  let(:provider) { resource.provider }
+  let(:provider) { described_class.new(resource) }
 
   context "#configure" do
     it "should add the create args to the create str" do
       resource.stubs(:properties).returns([])
       resource[:create_args] = "create_args"
-      provider.expects(:setconfig).with("create -b create_args\nset zonepath=\/\ncommit\n")
+      provider.expects(:setconfig).with("create -b create_args")
+      provider.configure
+    end
+    it "should add the create args to the create str" do
+      iptype = stub "property"
+      iptype.stubs(:name).with().returns(:iptype)
+      iptype.stubs(:safe_insync?).with(iptype).returns(false)
+      provider.stubs(:properties).returns({:iptype => iptype})
+      resource.stubs(:properties).with().returns([iptype])
+      resource[:create_args] = "create_args"
+      provider.expects(:setconfig).with("create -b create_args\nset ip-type=shared")
       provider.configure
     end
   end
@@ -59,18 +69,127 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
   end
   context "#setconfig" do
     it "should correctly set configuration" do
-      provider.expects(:cfg).with('-z', 'dummy', "create -b create_args\nset zonepath=\/\ncommit\n").returns('')
-      $CHILD_STATUS.stubs(:exitstatus).with().returns 0
-      provider.setconfig("create -b create_args\nset zonepath=\/\ncommit\n")
+      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
+      provider.expects(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 0})
+      provider.setconfig("set zonepath=\/")
+      provider.flush
     end
 
     it "should correctly warn on 'not allowed'" do
-      provider.expects(:cfg).with('-z', 'dummy', 'set zonepath=/').returns("Zone z2 already installed; set zonepath not allowed.\n")
+      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
+      provider.expects(:exec_cmd).with(:input => "set zonepath=/\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>"Zone z2 already installed; set zonepath not allowed.\n", :exit => 0})
+      provider.setconfig("set zonepath=\/")
       expect {
-        provider.setconfig("set zonepath=\/")
+        provider.flush
       }.to raise_error(ArgumentError, /Failed to apply configuration/)
+    end
+  end
+  context "#getconfig" do
+    zone_info =<<-EOF
+zonename: dummy
+zonepath: /dummy/z
+brand: native
+autoboot: true
+bootargs:
+pool:
+limitpriv:
+scheduling-class:
+ip-type: shared
+hostid:
+net:
+        address: 1.1.1.1
+        physical: ex0001
+        defrouter not specified
+net:
+        address: 1.1.1.2
+        physical: ex0002
+        defrouter not specified
+    EOF
+    it "should correctly parse zone info" do
+      provider.expects(:zonecfg).with(:info).returns(zone_info)
+      provider.getconfig.should == {
+        :brand=>"native",
+        :autoboot=>"true",
+        :"ip-type"=>"shared",
+        :zonename=>"dummy",
+        "net"=>[{:physical=>"ex0001", :address=>"1.1.1.1"}, {:physical=>"ex0002", :address=>"1.1.1.2"}],
+        :zonepath=>"/dummy/z"
+      }
+    end
+  end
+  context "#flush" do
+    it "should correctly execute pending commands" do
+      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
+      provider.expects(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 0})
+      provider.setconfig("set iptype=shared")
+      provider.flush
+    end
+
+    it "should correctly raise error on failure" do
+      provider.expects(:command).with(:cfg).returns('/usr/sbin/zonecfg')
+      provider.expects(:exec_cmd).with(:input => "set iptype=shared\ncommit\nexit", :cmd => '/usr/sbin/zonecfg -z dummy -f -').returns({:out=>'', :exit => 1})
+      provider.setconfig("set iptype=shared")
+      expect {
+        provider.flush
+      }.to raise_error(ArgumentError, /Failed to apply/)
+    end
+  end
+  context "#start" do
+    it "should not require path if sysidcfg is specified" do
+      resource[:path] = '/mypath'
+      resource[:sysidcfg] = 'dummy'
+      File.stubs(:exists?).with('/mypath/root/etc/sysidcfg').returns true
+      File.stubs(:directory?).with('/mypath/root/etc').returns true
+      provider.expects(:zoneadm).with(:boot)
+      provider.start
+    end
 
+    it "should require path if sysidcfg is specified" do
+      resource.stubs(:[]).with(:path).returns nil
+      resource.stubs(:[]).with(:sysidcfg).returns 'dummy'
+      expect {
+        provider.start
+      }.to raise_error(Puppet::Error, /Path is required/)
+    end
+  end
+  context "#line2hash" do
+    it "should parse lines correctly" do
+      described_class.line2hash('0:dummy:running:/z::native:shared').should == {:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"}
+    end
+    it "should parse lines correctly(2)" do
+      described_class.line2hash('0:dummy:running:/z:ipkg:native:shared').should == {:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy", :id=>"0"}
+    end
+    it "should parse lines correctly(3)" do
+      described_class.line2hash('-:dummy:running:/z:ipkg:native:shared').should == {:ensure=>:running, :iptype=>"shared", :path=>"/z", :name=>"dummy"}
+    end
+    it "should parse lines correctly(3)" do
+      described_class.line2hash('-:dummy:running:/z:ipkg:native:exclusive').should == {:ensure=>:running, :iptype=>"exclusive", :path=>"/z", :name=>"dummy"}
     end
+  end
+  context "#multi_conf" do
+    it "should correctly add and remove properties" do
+      provider.stubs(:properties).with().returns({:ip => ['1.1.1.1', '2.2.2.2']})
+      should = ['1.1.1.1', '3.3.3.3']
+      p = Proc.new do |a, str|
+        case a
+        when :add; 'add:' + str
+        when :rm; 'rm:' + str
+        end
+      end
+      provider.multi_conf(:ip, should, &p).should == "rm:2.2.2.2\nadd:3.3.3.3"
+    end
+  end
+  context "single props" do
+    {:iptype => /set ip-type/, :autoboot => /set autoboot/, :path => /set zonepath/, :pool => /set pool/, :shares => /add rctl/}.each do |p, v|
+      it "#{p.to_s}: should correctly return conf string" do
+        provider.send(p.to_s + '_conf', 'dummy').should =~ v
+      end
+      it "#{p.to_s}: should correctly set property string" do
+        provider.expects((p.to_s + '_conf').intern).returns('dummy')
+        provider.expects(:setconfig).with('dummy').returns('dummy2')
+        provider.send(p.to_s + '=', 'dummy').should == 'dummy2'
+      end
 
+    end
   end
 end