microwave 0.1006.33 → 1.0.0

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

@@ -0,0 +1,235 @@
+#
+# Author:: Stephen Haynes (<sh@nomitor.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::User::Pw do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    
+    @new_resource = Chef::Resource::User.new("adam")
+    @new_resource.comment   "Adam Jacob"
+    @new_resource.uid       1000
+    @new_resource.gid       1000
+    @new_resource.home      "/home/adam"
+    @new_resource.shell     "/usr/bin/zsh"
+    @new_resource.password  "abracadabra"
+    
+    @new_resource.supports :manage_home => true
+
+    @current_resource = Chef::Resource::User.new("adam")
+    @current_resource.comment  "Adam Jacob"
+    @current_resource.uid      1000
+    @current_resource.gid      1000
+    @current_resource.home     "/home/adam"
+    @current_resource.shell    "/usr/bin/zsh"
+    @current_resource.password "abracadabra"
+
+    @provider = Chef::Provider::User::Pw.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe "setting options to the pw command" do
+    field_list = {
+      'comment' => "-c",
+      'home' => "-d",
+      'gid' => "-g",
+      'uid' => "-u",
+      'shell' => "-s"
+    }
+    field_list.each do |attribute, option|
+      it "should check for differences in #{attribute} between the new and current resources" do
+        @current_resource.should_receive(attribute)
+        @new_resource.should_receive(attribute)
+        @provider.set_options
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not null" do
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.set_options.should eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}' -m")
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not null, without homedir management" do
+        @new_resource.stub!(:supports).and_return({:manage_home => false})
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.set_options.should eql(" #{@new_resource.username} #{option} '#{@new_resource.send(attribute)}'")
+      end
+    end
+
+    it "should combine all the possible options" do
+      match_string = " adam"
+      field_list.sort{ |a,b| a[0] <=> b[0] }.each do |attribute, option|
+        @new_resource.stub!(attribute).and_return("hola")
+        match_string << " #{option} 'hola'"
+      end
+      match_string << " -m"
+      @provider.set_options.should eql(match_string)
+    end
+  end
+
+  describe "create_user" do
+    before(:each) do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.stub!(:modify_password).and_return(true)
+    end
+
+    it "should run pw useradd with the return of set_options" do
+      @provider.should_receive(:run_command).with({ :command => "pw useradd adam -m" }).and_return(true)
+      @provider.create_user
+    end
+
+    it "should modify the password" do
+      @provider.should_receive(:modify_password).and_return(true)
+      @provider.create_user
+    end
+  end
+
+  describe "manage_user" do
+    before(:each) do
+      @provider.stub!(:run_command).and_return(true)
+      @provider.stub!(:modify_password).and_return(true)
+    end
+
+    it "should run pw usermod with the return of set_options" do
+      @provider.should_receive(:run_command).with({ :command => "pw usermod adam -m" }).and_return(true)
+      @provider.manage_user
+    end
+
+    it "should modify the password" do
+      @provider.should_receive(:modify_password).and_return(true)
+      @provider.create_user
+    end
+  end
+
+  describe "remove_user" do
+    it "should run pw userdel with the new resources user name" do
+      @new_resource.supports :manage_home => false
+      @provider.should_receive(:run_command).with({ :command => "pw userdel #{@new_resource.username}" }).and_return(true)
+      @provider.remove_user
+    end
+
+    it "should run pw userdel with the new resources user name and -r if manage_home is true" do
+      @provider.should_receive(:run_command).with({ :command => "pw userdel #{@new_resource.username} -r"}).and_return(true)
+      @provider.remove_user
+    end
+  end
+
+  describe "determining if the user is locked" do
+    it "should return true if user is locked" do
+      @current_resource.stub!(:password).and_return("*LOCKED*abracadabra")
+      @provider.check_lock.should eql(true)
+    end
+
+    it "should return false if user is not locked" do
+      @current_resource.stub!(:password).and_return("abracadabra")
+      @provider.check_lock.should eql(false)
+    end
+  end
+
+  describe "when locking the user" do
+    it "should run pw lock with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "pw lock #{@new_resource.username}"})
+      @provider.lock_user
+    end
+  end
+
+  describe "when unlocking the user" do
+    it "should run pw unlock with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "pw unlock #{@new_resource.username}"})
+      @provider.unlock_user
+    end
+  end
+
+  describe "when modifying the password" do
+    before(:each) do
+      @status = mock("Status", :exitstatus => 0)
+      @provider.stub!(:popen4).and_return(@status)
+      @pid, @stdin, @stdout, @stderr = nil, nil, nil, nil
+    end
+
+    it "should check for differences in password between the new and current resources" do
+      @current_resource.should_receive(:password)
+      @new_resource.should_receive(:password)
+      @provider.modify_password
+    end
+
+    describe "and the passwords are identical" do
+      before(:each) do
+        @new_resource.stub!(:password).and_return("abracadabra")
+        @current_resource.stub!(:password).and_return("abracadabra")
+      end
+
+      it "logs an appropriate message" do
+        Chef::Log.should_receive(:debug).with("user[adam] no change needed to password")
+        @provider.modify_password
+      end
+    end
+
+    describe "and the passwords are different" do
+      before(:each) do
+        @new_resource.stub!(:password).and_return("abracadabra")
+        @current_resource.stub!(:password).and_return("sesame")
+      end
+
+      it "should log an appropriate message" do
+        Chef::Log.should_receive(:debug).with("user[adam] updating password")
+        @provider.modify_password
+      end
+
+      it "should run pw usermod with the username and the option -H 0" do
+        @provider.should_receive(:popen4).with("pw usermod adam -H 0", :waitlast => true).and_return(@status)
+        @provider.modify_password
+      end
+
+      it "should send the new password to the stdin of pw usermod" do
+        @stdin = StringIO.new
+        @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        @provider.modify_password
+        @stdin.string.should == "abracadabra\n"
+      end
+
+      it "should raise an exception if pw usermod fails" do
+        @status.should_receive(:exitstatus).and_return(1)
+        lambda { @provider.modify_password }.should raise_error(Chef::Exceptions::User)
+      end
+
+      it "should not raise an exception if pw usermod succeeds" do
+        @status.should_receive(:exitstatus).and_return(0)
+        lambda { @provider.modify_password }.should_not raise_error(Chef::Exceptions::User)
+      end
+    end
+  end
+
+  describe "when loading the current state" do
+    before do
+      @provider.new_resource = Chef::Resource::User.new("adam")
+    end
+
+    it "should raise an error if the required binary /usr/sbin/pw doesn't exist" do
+      File.should_receive(:exists?).with("/usr/sbin/pw").and_return(false)
+      lambda { @provider.load_current_resource }.should raise_error(Chef::Exceptions::User)
+    end
+
+    it "shouldn't raise an error if /usr/sbin/pw exists" do
+      File.stub!(:exists?).and_return(true)
+      lambda { @provider.load_current_resource }.should_not raise_error(Chef::Exceptions::User)
+    end
+  end
+end

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

@@ -0,0 +1,386 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Provider::User::Useradd do
+  before(:each) do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+
+    @new_resource = Chef::Resource::User.new("adam", @run_context)
+    @new_resource.comment "Adam Jacob"
+    @new_resource.uid 1000
+    @new_resource.gid 1000
+    @new_resource.home "/home/adam"
+    @new_resource.shell "/usr/bin/zsh"
+    @new_resource.password "abracadabra"
+    @new_resource.system false
+    @new_resource.manage_home false
+    @new_resource.non_unique false
+    @current_resource = Chef::Resource::User.new("adam", @run_context)
+    @current_resource.comment "Adam Jacob"
+    @current_resource.uid 1000
+    @current_resource.gid 1000
+    @current_resource.home "/home/adam"
+    @current_resource.shell "/usr/bin/zsh"
+    @current_resource.password "abracadabra"
+    @current_resource.system false
+    @current_resource.manage_home false
+    @current_resource.non_unique false
+    @current_resource.supports({:manage_home => false, :non_unique => false})
+    @provider = Chef::Provider::User::Useradd.new(@new_resource, @run_context)
+    @provider.current_resource = @current_resource
+  end
+
+  describe "when setting option" do
+    field_list = {
+      'comment' => "-c",
+      'gid' => "-g",
+      'uid' => "-u",
+      'shell' => "-s",
+      'password' => "-p"
+    }
+
+    field_list.each do |attribute, option|
+      it "should check for differences in #{attribute} between the new and current resources" do
+        @current_resource.should_receive(attribute)
+        @new_resource.should_receive(attribute)
+        @provider.universal_options
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not nil" do
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.universal_options.should eql(" #{option} 'hola'")
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not nil, without homedir management" do
+        @new_resource.stub!(:supports).and_return({:manage_home => false,
+                                                    :non_unique => false})
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.universal_options.should eql(" #{option} 'hola'")
+      end
+
+      it "should set the option for #{attribute} if the new resources #{attribute} is not nil, without homedir management (using real attributes)" do
+        @new_resource.stub!(:manage_home).and_return(false)
+        @new_resource.stub!(:non_unique).and_return(false)
+        @new_resource.stub!(attribute).and_return("hola")
+        @provider.universal_options.should eql(" #{option} 'hola'")
+      end
+    end
+
+    it "should combine all the possible options" do
+      match_string = ""
+      field_list.sort{ |a,b| a[0] <=> b[0] }.each do |attribute, option|
+        @new_resource.stub!(attribute).and_return("hola")
+        match_string << " #{option} 'hola'"
+      end
+      @provider.universal_options.should eql(match_string)
+    end
+
+    describe "when we want to create a system user" do
+      before do
+        @new_resource.manage_home(true)
+        @new_resource.non_unique(false)
+      end
+
+      it "should set useradd -r" do
+        @new_resource.system(true)
+        @provider.useradd_options.should == " -r"
+      end
+    end
+
+    describe "when the resource has a different home directory and supports home directory management" do
+      before do
+        @new_resource.stub!(:home).and_return("/wowaweea")
+        @new_resource.stub!(:supports).and_return({:manage_home => true,
+                                                   :non_unique => false})
+      end
+
+      it "should set -m -d /homedir" do
+        @provider.universal_options.should == " -m -d '/wowaweea'"
+        @provider.useradd_options.should == ""
+      end
+    end
+
+    describe "when the resource has a different home directory and supports home directory management (using real attributes)" do
+      before do
+        @new_resource.stub!(:home).and_return("/wowaweea")
+        @new_resource.stub!(:manage_home).and_return(true)
+        @new_resource.stub!(:non_unique).and_return(false)
+      end
+
+      it "should set -m -d /homedir" do
+        @provider.universal_options.should eql(" -m -d '/wowaweea'")
+        @provider.useradd_options.should == ""
+      end
+    end
+
+    describe "when the resource supports non_unique ids" do
+      before do
+        @new_resource.stub!(:supports).and_return({:manage_home => false,
+                                                  :non_unique => true})
+      end
+
+      it "should set -m -o" do
+        @provider.universal_options.should eql(" -o")
+      end
+    end
+
+    describe "when the resource supports non_unique ids (using real attributes)" do
+      before do
+        @new_resource.stub!(:manage_home).and_return(false)
+        @new_resource.stub!(:non_unique).and_return(true)
+      end
+
+      it "should set -m -o" do
+        @provider.universal_options.should eql(" -o")
+      end
+    end
+  end
+
+  describe "when creating a user" do
+    before(:each) do
+      @current_resource = Chef::Resource::User.new(@new_resource.name, @run_context)
+      @current_resource.username(@new_resource.username)
+      @provider.current_resource = @current_resource
+      @provider.new_resource.manage_home true
+      @provider.new_resource.home "/Users/mud"
+      @provider.new_resource.gid '23'
+    end
+
+    it "runs useradd with the computed command options" do
+      command = "useradd -c 'Adam Jacob' -g '23' -p 'abracadabra' -s '/usr/bin/zsh' -u '1000' -m -d '/Users/mud' adam"
+      @provider.should_receive(:run_command).with({ :command => command }).and_return(true)
+      @provider.create_user
+    end
+
+    describe "and home is not specified for new system user resource" do
+
+      before do
+        @provider.new_resource.system true
+        # there is no public API to set attribute's value to nil 
+        @provider.new_resource.instance_variable_set("@home", nil)
+      end
+
+      it "should not include -m or -d in the command options" do
+        command = "useradd -c 'Adam Jacob' -g '23' -p 'abracadabra' -s '/usr/bin/zsh' -u '1000' -r adam"
+        @provider.should_receive(:run_command).with({ :command => command }).and_return(true)
+        @provider.create_user
+      end
+
+    end
+
+  end
+
+  describe "when managing a user" do
+    before(:each) do
+      @provider.new_resource.manage_home true
+      @provider.new_resource.home "/Users/mud"
+      @provider.new_resource.gid '23'
+    end
+
+    # CHEF-3423, -m must come before the username
+    it "runs usermod with the computed command options" do
+      @provider.should_receive(:run_command).with({ :command => "usermod -g '23' -m -d '/Users/mud' adam" }).and_return(true)
+      @provider.manage_user
+    end
+
+    it "does not set the -r option to usermod" do
+      @new_resource.system(true)
+      @provider.should_receive(:run_command).with({ :command => "usermod -g '23' -m -d '/Users/mud' adam" }).and_return(true)
+      @provider.manage_user
+    end
+
+    it "CHEF-3429: does not set -m if we aren't changing the home directory" do
+      @provider.should_receive(:updating_home?).and_return(false)
+      @provider.should_receive(:run_command).with({ :command => "usermod -g '23' adam" }).and_return(true)
+      @provider.manage_user
+    end
+  end
+
+  describe "when removing a user" do
+
+    it "should run userdel with the new resources user name" do
+      @provider.should_receive(:run_command).with({ :command => "userdel #{@new_resource.username}" }).and_return(true)
+      @provider.remove_user
+    end
+
+    it "should run userdel with the new resources user name and -r if manage_home is true" do
+      @new_resource.stub!(:supports).and_return({ :manage_home => true,
+                                                  :non_unique => false})
+      @provider.should_receive(:run_command).with({ :command => "userdel -r #{@new_resource.username}"}).and_return(true)
+      @provider.remove_user
+    end
+
+    it "should run userdel with the new resources user name if non_unique is true" do
+      @new_resource.stub!(:supports).and_return({ :manage_home => false,
+                                                  :non_unique => true})
+      @provider.should_receive(:run_command).with({ :command => "userdel #{@new_resource.username}"}).and_return(true)
+      @provider.remove_user
+    end
+  end
+
+  describe "when checking the lock" do
+    before(:each) do
+      # @node = Chef::Node.new
+      # @new_resource = mock("Chef::Resource::User",
+      #   :nil_object => true,
+      #   :username => "adam"
+      # )
+      @status = mock("Status", :exitstatus => 0)
+      #@provider = Chef::Provider::User::Useradd.new(@node, @new_resource)
+      @provider.stub!(:popen4).and_return(@status)
+      @stdin = mock("STDIN", :nil_object => true)
+      @stdout = mock("STDOUT", :nil_object => true)
+      @stdout.stub!(:gets).and_return("root P 09/02/2008 0 99999 7 -1")
+      @stderr = mock("STDERR", :nil_object => true)
+      @pid = mock("PID", :nil_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 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::Exceptions::User if passwd -S fails on anything other than redhat/centos" do
+      @node.automatic_attrs[:platform] = 'ubuntu'
+      @status.should_receive(:exitstatus).and_return(1)
+      lambda { @provider.check_lock }.should raise_error(Chef::Exceptions::User)
+    end
+
+    ['redhat', 'centos'].each do |os|
+      it "should not raise a Chef::Exceptions::User if passwd -S exits with 1 on #{os} and the passwd package is version 0.73-1" do
+        @node.automatic_attrs[:platform] = os
+        @stdout.stub!(:gets).and_return("passwd-0.73-1\n")
+        @status.should_receive(:exitstatus).twice.and_return(1)
+        @provider.should_receive(:popen4).with("passwd -S #{@new_resource.username}")
+        @provider.should_receive(:popen4).with("rpm -q passwd").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        lambda { @provider.check_lock }.should_not raise_error(Chef::Exceptions::User)
+      end
+
+      it "should raise a Chef::Exceptions::User if passwd -S exits with 1 on #{os} and the passwd package is not version 0.73-1" do
+        @node.automatic_attrs[:platform] = os
+        @stdout.stub!(:gets).and_return("passwd-0.73-2\n")
+        @status.should_receive(:exitstatus).twice.and_return(1)
+        @provider.should_receive(:popen4).with("passwd -S #{@new_resource.username}")
+        @provider.should_receive(:popen4).with("rpm -q passwd").and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
+        lambda { @provider.check_lock }.should raise_error(Chef::Exceptions::User)
+      end
+
+      it "should raise a Chef::Exceptions::User if passwd -S exits with something other than 0 or 1 on #{os}" do
+        @node.automatic_attrs[:platform] = os
+        @status.should_receive(:exitstatus).twice.and_return(2)
+        lambda { @provider.check_lock }.should raise_error(Chef::Exceptions::User)
+      end
+    end
+  end
+
+  describe "when locking the user" do
+    it "should run usermod -L with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "usermod -L #{@new_resource.username}"})
+      @provider.lock_user
+    end
+  end
+
+  describe "when unlocking the user" do
+    it "should run usermod -L with the new resources username" do
+      @provider.should_receive(:run_command).with({ :command => "usermod -U #{@new_resource.username}"})
+      @provider.unlock_user
+    end
+  end
+
+  describe "when checking if home needs updating" do
+    [
+     {
+       "action" => "should return false if home matches",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/home/laurent" ],
+       "expected_result" => false
+     },
+     {
+       "action" => "should return true if home doesn't match",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/something/else" ],
+       "expected_result" => true
+     },
+     {
+       "action" => "should return false if home only differs by trailing slash",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/home/laurent/", "/home/laurent" ],
+       "expected_result" => false
+     },
+     {
+       "action" => "should return false if home is an equivalent path",
+       "current_resource_home" => [ "/home/laurent" ],
+       "new_resource_home" => [ "/home/./laurent", "/home/laurent" ],
+       "expected_result" => false
+     },
+    ].each do |home_check|
+      it home_check["action"] do
+        @provider.current_resource.home home_check["current_resource_home"].first
+        @current_home_mock = mock("Pathname")
+        @provider.new_resource.home home_check["new_resource_home"].first
+        @new_home_mock = mock("Pathname")
+
+        Pathname.should_receive(:new).with(@current_resource.home).and_return(@current_home_mock)
+        @current_home_mock.should_receive(:cleanpath).and_return(home_check["current_resource_home"].last)
+        Pathname.should_receive(:new).with(@new_resource.home).and_return(@new_home_mock)
+        @new_home_mock.should_receive(:cleanpath).and_return(home_check["new_resource_home"].last)
+
+        @provider.updating_home?.should == home_check["expected_result"]
+      end
+    end
+    it "should return true if the current home does not exist but a home is specified by the new resource" do
+      @new_resource = Chef::Resource::User.new("adam", @run_context)
+      @current_resource = Chef::Resource::User.new("adam", @run_context)
+      @provider = Chef::Provider::User::Useradd.new(@new_resource, @run_context)
+      @provider.current_resource = @current_resource
+      @current_resource.home nil
+      @new_resource.home "/home/kitten"
+
+      @provider.updating_home?.should == true
+    end
+  end
+end