Updating the user provider and the user_spec, much more coverage

Author: adamhjk

chef/lib/chef/provider/user.rb

@@ -116,10 +116,12 @@ def action_manage
       end
 
       def action_modify
-        if @user_exists && compare_user
-          manage_user
-          @new_resource.updated = true
-          Chef::Log.info("Modified #{@new_resource}")
+        if @user_exists 
+          if compare_user
+            manage_user
+            @new_resource.updated = true
+            Chef::Log.info("Modified #{@new_resource}")
+          end
         else
           raise Chef::Exception::User, "Cannot modify #{@new_resource} - user does not exist!"
         end

chef/spec/unit/provider/user_spec.rb

@@ -169,8 +169,7 @@
 
   it "should return false if the objects are identical" do
     @provider.compare_user.should eql(false)
-  end
-  
+  end  
 end
 
 describe Chef::Provider::User, "action_create" do
@@ -235,33 +234,16 @@
     @new_resource.should_receive(:updated=).with(true).and_return(true)
     @provider.action_create
   end
-  
 end
 
 describe Chef::Provider::User, "action_remove" do
   before(:each) do
     @node = mock("Chef::Node", :null_object => true)
     @new_resource = mock("Chef::Resource::User", 
-      :null_object => true,
-      :username => "adam",
-      :comment => "Adam Jacob",
-      :uid => 1000,
-      :gid => 1000,
-      :home => "/home/adam",
-      :shell => "/usr/bin/zsh",
-      :password => nil,
-      :updated => nil
+      :null_object => true
     )
     @current_resource = mock("Chef::Resource::User", 
-      :null_object => true,
-      :username => "adam",
-      :comment => "Adam Jacob",
-      :uid => 1000,
-      :gid => 1000,
-      :home => "/home/adam",
-      :shell => "/usr/bin/zsh",
-      :password => nil,
-      :updated => nil
+      :null_object => true
     )
     @provider = Chef::Provider::User.new(@node, @new_resource)
     @provider.current_resource = @current_resource
@@ -291,48 +273,202 @@
   before(:each) do
     @node = mock("Chef::Node", :null_object => true)
     @new_resource = mock("Chef::Resource::User", 
-      :null_object => true,
-      :username => "adam",
-      :comment => "Adam Jacob",
-      :uid => 1000,
-      :gid => 1000,
-      :home => "/home/adam",
-      :shell => "/usr/bin/zsh",
-      :password => nil,
-      :updated => nil
+      :null_object => true
     )
     @current_resource = mock("Chef::Resource::User", 
-      :null_object => true,
-      :username => "adam",
-      :comment => "Adam Jacob",
-      :uid => 1000,
-      :gid => 1000,
-      :home => "/home/adam",
-      :shell => "/usr/bin/zsh",
-      :password => nil,
-      :updated => nil
+      :null_object => true
     )
     @provider = Chef::Provider::User.new(@node, @new_resource)
     @provider.current_resource = @current_resource
-    @provider.user_exists = false
-    @provider.stub!(:remove_user).and_return(true)
+    @provider.user_exists = true
+    @provider.stub!(:manage_user).and_return(true)
+  end
+ 
+  it "should run manage_user if the user exists and has mismatched attributes" do
+    @provider.should_receive(:compare_user).and_return(true)
+    @provider.should_receive(:manage_user).and_return(true)
+    @provider.action_manage
   end
 
-  it "should not call remove_user if the user does not exist" do
-    @provider.should_not_receive(:remove_user) 
-    @provider.action_remove
+  it "should set the new resources updated flag to true if manage_user is called" do
+    @provider.stub!(:compare_user).and_return(true)
+    @provider.stub!(:manage_user).and_return(true)
+    @new_resource.should_receive(:updated=).with(true).and_return(true)
+    @provider.action_manage
   end
 
-  it "should call remove_user if the user exists" do
-    @provider.user_exists = true
-    @provider.should_receive(:remove_user)
-    @provider.action_remove
+  it "should not run manage_user if the user does not exist" do
+    @provider.user_exists = false
+    @provider.should_not_receive(:manage_user)
+    @provider.action_manage
   end
 
-  it "should set the new_resources updated flag to true if the user is removed" do
+  it "should not run manage_user if the user exists but has no differing attributes" do
+    @provider.should_receive(:compare_user).and_return(false)
+    @provider.should_not_receive(:manage_user)
+    @provider.action_manage
+  end
+end
+
+describe Chef::Provider::User, "action_modify" do
+  before(:each) do
+    @node = mock("Chef::Node", :null_object => true)
+    @new_resource = mock("Chef::Resource::User", 
+      :null_object => true
+    )
+    @current_resource = mock("Chef::Resource::User", 
+      :null_object => true
+    )
+    @provider = Chef::Provider::User.new(@node, @new_resource)
+    @provider.current_resource = @current_resource
     @provider.user_exists = true
+    @provider.stub!(:manage_user).and_return(true)
+  end
+ 
+  it "should run manage_user if the user exists and has mismatched attributes" do
+    @provider.should_receive(:compare_user).and_return(true)
+    @provider.should_receive(:manage_user).and_return(true)
+    @provider.action_modify
+  end
+  
+  it "should set the new resources updated flag to true if manage_user is called" do
+    @provider.stub!(:compare_user).and_return(true)
+    @provider.stub!(:manage_user).and_return(true)
     @new_resource.should_receive(:updated=).with(true).and_return(true)
-    @provider.action_remove
+    @provider.action_modify
+  end
+  
+  it "should not run manage_user if the user exists but has no differing attributes" do
+    @provider.should_receive(:compare_user).and_return(false)
+    @provider.should_not_receive(:manage_user)
+    @provider.action_modify
+  end
+  
+  it "should raise a Chef::Exception::User if the user doesn't exist" do
+    @provider.user_exists = false
+    lambda { @provider.action_modify }.should raise_error(Chef::Exception::User)
+  end
+end
+
+describe Chef::Provider::User, "check_lock" do
+  before(:each) do
+    @node = mock("Chef::Node", :null_object => true)
+    @new_resource = mock("Chef::Resource::User", 
+      :null_object => true,
+      :username => "adam"
+    )
+    @status = mock("Status", :exitstatus => 0)
+    @provider = Chef::Provider::User.new(@node, @new_resource)    
+    @provider.stub!(:popen4).and_return(@status)
+    @stdin = mock("STDIN", :null_object => true)
+    @stdout = mock("STDOUT", :null_object => true)    
+    @stdout.stub!(:gets).and_return("root P 09/02/2008 0 99999 7 -1")
+    @stderr = mock("STDERR", :null_object => true)
+    @pid = mock("PID", :null_object => true)
+  end
+  
+  it "should call passwd -S to check the lock status" do
+    @provider.should_receive(:popen4).with("passwd -S #{@new_resource.username}").and_return(@status)
+    @provider.check_lock
+  end
+  
+  it "should close stdin on passwd -S" do
+    @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+    @stdin.should_receive(:close).and_return(true)
+    @provider.check_lock
+  end
+  
+  it "should get the first line of passwd -S STDOUT" do
+    @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+    @stdout.should_receive(:gets).and_return("root P 09/02/2008 0 99999 7 -1")
+    @provider.check_lock
+  end
+  
+  it "should return false if status begins with P" do
+    @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+    @provider.check_lock.should eql(false)
+  end
+  
+  it "should return false if status begins with N" do
+    @stdout.stub!(:gets).and_return("root N")
+    @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+    @provider.check_lock.should eql(false)
+  end
+  
+  it "should return true if status begins with L" do
+    @stdout.stub!(:gets).and_return("root L")
+    @provider.should_receive(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+    @provider.check_lock.should eql(true)
+  end
+  
+  it "should raise a Chef::Exception::User if passwd -S fails" do
+    @status.should_receive(:exitstatus).and_return(1)
+    lambda { @provider.check_lock }.should raise_error(Chef::Exception::User)
   end
 end
 
+describe Chef::Provider::User, "action_lock" do
+  before(:each) do
+    @node = mock("Chef::Node", :null_object => true)
+    @new_resource = mock("Chef::Resource::User", 
+      :null_object => true
+    )
+    @current_resource = mock("Chef::Resource::User", 
+      :null_object => true
+    )
+    @provider = Chef::Provider::User.new(@node, @new_resource)
+    @provider.current_resource = @current_resource
+    @provider.user_exists = true
+    @provider.stub!(:check_lock).and_return(true)
+    @provider.stub!(:lock_user).and_return(true)
+  end
+ 
+  it "should lock the user if it exists and is unlocked" do
+    @provider.stub!(:check_lock).and_return(false)
+    @provider.should_receive(:lock_user).and_return(true)
+    @provider.action_lock
+  end
+ 
+  it "should set the new resources updated flag to true if lock_user is called" do
+    @provider.stub!(:check_lock).and_return(false)
+    @new_resource.should_receive(:updated=).with(true)
+    @provider.action_lock
+  end
+  
+  it "should raise a Chef::Exception::User if we try and lock a user that does not exist" do
+    @provider.user_exists = false
+    lambda { @provider.action_lock }.should raise_error(Chef::Exception::User)
+  end
+end
+
+describe Chef::Provider::User, "action_unlock" do
+  before(:each) do
+    @node = mock("Chef::Node", :null_object => true)
+    @new_resource = mock("Chef::Resource::User", 
+      :null_object => true
+    )
+    @current_resource = mock("Chef::Resource::User", 
+      :null_object => true
+    )
+    @provider = Chef::Provider::User.new(@node, @new_resource)
+    @provider.current_resource = @current_resource
+    @provider.user_exists = true
+    @provider.stub!(:check_lock).and_return(true)
+    @provider.stub!(:unlock_user).and_return(true)
+  end
+ 
+  it "should unlock the user if it exists and is locked" do
+    @provider.should_receive(:unlock_user).and_return(true)
+    @provider.action_unlock
+  end
+ 
+  it "should set the new resources updated flag to true if unlock_user is called" do
+    @new_resource.should_receive(:updated=).with(true)
+    @provider.action_unlock
+  end
+  
+  it "should raise a Chef::Exception::User if we try and unlock a user that does not exist" do
+    @provider.user_exists = false
+    lambda { @provider.action_unlock }.should raise_error(Chef::Exception::User)
+  end
+end