sys-admin 1.5.6 → 1.6.0

data/sys-admin.gemspec

@@ -4,7 +4,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'sys-admin'
-  spec.version   = '1.5.6'
+  spec.version   = '1.6.0'
   spec.author    = 'Daniel J. Berger'
   spec.license   = 'Artistic 2.0'
   spec.email     = 'djberg96@gmail.com'
@@ -16,7 +16,8 @@ Gem::Specification.new do |spec|
   spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
   spec.rubyforge_project = 'sysutils'
 	
-  spec.add_development_dependency('test-unit', '>= 2.1.1')
+  spec.add_dependency('ffi', '>= 1.1.0')
+  spec.add_development_dependency('test-unit', '>= 2.5.0')
 
   spec.description = <<-EOF
     The sys-admin library is a unified, cross platform replacement for the

data/test/test_sys_admin.rb

@@ -4,9 +4,7 @@
 # This exists mostly for the sake of the gemspec, so that it calls the right
 # test suite based on the platform.
 ###############################################################################
-require 'rubygems'
-gem 'test-unit'
-require 'test/unit'
+require 'test-unit'
 
 if File::ALT_SEPARATOR
   require 'test_sys_admin_windows'
@@ -15,7 +13,7 @@ else
 end
 
 class TC_Sys_Admin_All < Test::Unit::TestCase
-  def test_version
-    assert_equal('1.5.6', Sys::Admin::VERSION)
+  test "version is set to expected value" do
+    assert_equal('1.6.0', Sys::Admin::VERSION)
   end
 end

data/test/test_sys_admin_unix.rb

@@ -4,7 +4,7 @@
 # Test suite for the Unix version of sys-admin. This test should be run
 # via the 'rake test' task.
 ###############################################################################
-require 'test/unit'
+require 'test-unit'
 require 'sys/admin'
 include Sys
 
@@ -18,224 +18,239 @@ class TC_Sys_Admin_Unix < Test::Unit::TestCase
 
   ## Admin singleton methods
 
-  def test_get_login
+  test "get_login basic functionality" do
     assert_respond_to(Admin, :get_login)
     assert_nothing_raised{ Admin.get_login }
+  end
+
+  test "get_login returns a string" do
     assert_kind_of(String, Admin.get_login)
+    assert_true(Admin.get_login.length > 0)
   end
 
-  def test_get_user_basic
+  test "get_user basic functionality" do
     assert_respond_to(Admin, :get_user)
     assert_nothing_raised{ Admin.get_user(@user) }
     assert_nothing_raised{ Admin.get_user(@user_id) }
   end
 
-  def test_get_user_by_name
-    assert_kind_of(User, Admin.get_user(@user))
+  test "get_user with a string argument works as expected" do
+    assert_kind_of(Admin::User, Admin.get_user(@user))
   end
 
-  def test_get_user_by_id
-    assert_kind_of(User, Admin.get_user(@user_id))
+  test "get_user with an integer argument works as expected" do
+    assert_kind_of(Admin::User, Admin.get_user(@user_id))
   end
 
-  def test_get_user_expected_errors
+  test "get_user requires one argument only" do
     assert_raise(ArgumentError){ Admin.get_user }
+    assert_raise(ArgumentError){ Admin.get_user(@user, @user) }
+  end
+
+  test "get_user requires a string or integer argument" do
     assert_raise(TypeError){ Admin.get_user([]) }
+  end
+
+  test "get_user raises an Error if the user cannot be found" do
     assert_raise(Admin::Error){ Admin.get_user('foofoofoo') }
   end
 
-  def test_users_basic
+  test "users basic functionality" do
     assert_respond_to(Admin, :users)
     assert_nothing_raised{ Admin.users }
   end
 
-  def test_users
-    assert_kind_of(Array, Admin.users)
-    assert_kind_of(User, Admin.users.first)
-  end
-
-  def test_users_block_form
-    array = []
-    assert_nothing_raised{ Admin.users{ |g| array << g } }
-    assert_equal(true, Admin.users.length == array.length)
-    assert_nothing_raised{ Admin.users{ |g| break } }
+  test "users returns an array of User objects" do
+    users = Admin.users
+    assert_kind_of(Array, users)
+    assert_kind_of(Admin::User, users.first)
   end
 
-  def test_users_expected_errors
+  test "users does not accept any arguments" do
     assert_raise(ArgumentError){ Admin.users(@user_id) }
   end
 
-  def test_get_group_basic
+  test "get_group basic functionality" do
     assert_respond_to(Admin, :get_group)
     assert_nothing_raised{ Admin.get_group(@group) }
     assert_nothing_raised{ Admin.get_group(@group_id) }
   end
 
-  def test_get_group_by_name
-    assert_kind_of(Group, Admin.get_group(@group))
+  test "get_group accepts a string argument" do
+    assert_kind_of(Admin::Group, Admin.get_group(@group))
   end
 
-  def test_get_group_by_id
-    assert_kind_of(Group, Admin.get_group(@group_id))
+  test "get_group accepts an integer argument" do
+    assert_kind_of(Admin::Group, Admin.get_group(@group_id))
   end
 
-  def test_get_group_expected_errors
+  test "get_group requires one argument only" do
     assert_raise(ArgumentError){ Admin.get_group }
+    assert_raise(ArgumentError){ Admin.get_group(@group_id, @group_id) }
+  end
+
+  test "get_group raises a TypeError if an invalid type is passed" do
     assert_raise(TypeError){ Admin.get_group([]) }
+  end
+
+  test "get_group raises an Error if the group cannot be found" do
     assert_raise(Admin::Error){ Admin.get_group('foofoofoo') }
   end
 
-  def test_groups_basic
+  test "groups basic functionality" do
     assert_respond_to(Admin, :groups)
     assert_nothing_raised{ Admin.groups }
   end
 
-  def test_groups
-    assert_kind_of(Array, Admin.groups)
-    assert_kind_of(Group, Admin.groups.first)
+  test "groups returns an array of Group objects" do
+    groups = Admin.groups
+    assert_kind_of(Array, groups)
+    assert_kind_of(Admin::Group, groups.first)
   end
 
-  def test_groups_expected_errors
+  test "groups method does not accept any arguments" do
     assert_raise(ArgumentError){ Admin.groups(@group_id) }
   end
 
-  def test_groups_block_form
-    array = []
-    assert_nothing_raised{ Admin.groups{ |g| array << g } }
-    assert_equal(true, Admin.groups.length == array.length)
-    assert_nothing_raised{ Admin.groups{ |g| break } }
-  end
-
   ## User Tests
 
-  def test_user_name
-    @user = Admin.users.first
+  test "user.name behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :name)
     assert_kind_of(String, @user.name)
   end
 
-  def test_user_passwd
-    @user = Admin.users.first
+  test "user.passwd behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :passwd)
     assert_kind_of(String, @user.passwd)
   end
 
-  def test_user_uid
-    @user = Admin.users.first
+  test "user.uid behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :uid)
     assert_kind_of(Fixnum, @user.uid)
   end
 
-  def test_user_gid
-    @user = Admin.users.first
+  test "user.gid behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :gid)
     assert_kind_of(Fixnum, @user.gid)
   end
 
-  def test_user_dir
-    @user = Admin.users.first
+  test "user.dir behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :dir)
     assert_kind_of(String, @user.dir)
   end
 
-  def test_user_shell
-    @user = Admin.users.first
+  test "user.shell behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :shell)
     assert_kind_of(String, @user.shell)
   end
 
-  def test_user_gecos
-    @user = Admin.users.first
+  test "user.gecos behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :gecos)
-    assert_kind_of(String, @user.gecos)
+    assert_kind_of([String, NilClass], @user.gecos)
   end
 
-  def test_user_quota
-    @user = Admin.users.first
+  test "user.quota behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :quota)
     assert_true([Fixnum, NilClass].include?(@user.quota.class))
   end
 
-  def test_user_age
-    @user = Admin.users.first
+  test "user.age behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :age)
     assert_true([Fixnum, NilClass].include?(@user.age.class))
   end
 
-  def test_user_access_class
-    @user = Admin.users.first
+  test "user.access behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :access_class)
     assert_true([String, NilClass].include?(@user.access_class.class))
   end
 
-  def test_user_comment
-    @user = Admin.users.first
+  test "user.comment behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :comment)
     assert_true([String, NilClass].include?(@user.comment.class))
   end
 
-  def test_user_expire
-    @user = Admin.users.first
+  test "user.expire behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :expire)
     assert_true([Time, NilClass].include?(@user.expire.class))
   end
 
-  def test_user_change
-    @user = Admin.users.first
+  test "user.change behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :change)
     assert_true([Time, NilClass].include?(@user.change.class))
   end
 
-  def test_user_login_time
-    @user = Admin.users.first
+  test "user.login_time behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :login_time)
     assert_true([Time, NilClass].include?(@user.login_time.class))
   end
 
-  def test_user_login_device
-    @user = Admin.users.first
+  test "user.login_device behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :login_device)
     assert_true([String, NilClass].include?(@user.login_device.class))
   end
 
-  def test_user_login_host
-    @user = Admin.users.first
+  test "user.login_host behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :login_host)
     assert_true([String, NilClass].include?(@user.login_host.class))
   end
 
-  def test_user_groups
-    @user = Admin.users.first
+  test "user.groups behaves as expected" do
+    @user = Admin.get_user(@user_id)
     assert_respond_to(@user, :groups)
     assert_kind_of(Array, @user.groups)
   end
 
   ## Group Tests
 
-  def test_group_name
-    @group = Admin.groups.first
+  test "group.name behaves as expected" do
+    @group = Admin.get_group(@group_id)
     assert_respond_to(@group, :name)
     assert_kind_of(String, @group.name)
   end
 
-  def test_group_gid
-    @group = Admin.groups.first
+  test "group.gid behaves as expected" do
+    @group = Admin.get_group(@group_id)
     assert_respond_to(@group, :gid)
     assert_kind_of(Fixnum, @group.gid)
   end
 
-  def test_group_members
-    @group = Admin.groups.first
+  test "group.members behaves as expected" do
+    @group = Admin.get_group(@group_id)
     assert_respond_to(@group, :members)
     assert_kind_of(Array, @group.members)
   end
 
-  def test_group_passwd
-    @group = Admin.groups.first
+  test "group.passwd behaves as expected" do
+    @group = Admin.get_group(@group_id)
     assert_respond_to(@group, :passwd)
     assert_kind_of(String, @group.passwd)
   end
 
+  ## FFI
+
+  test "ffi functions are private" do
+    methods = Admin.methods(false).map{ |e| e.to_s }
+    assert_false(methods.include?('getlogin'))
+    assert_false(methods.include?('getlogin_r'))
+    assert_false(methods.include?('strerror'))
+  end
+
   def teardown
     @user     = nil
     @user_id  = nil

data/test/test_sys_admin_windows.rb

@@ -7,20 +7,23 @@
 #
 # It is assumed that this test will be run via the 'rake test' task.
 ###############################################################################
-require 'rubygems'
-gem 'test-unit'
-
-require 'test/unit'
+require 'test-unit'
 require 'sys/admin'
 require 'win32/security'
 require 'socket'
-require 'etc'
 include Sys
 
 class TC_Sys_Admin_Win32 < Test::Unit::TestCase
   def self.startup
     @@host = Socket.gethostname
-    @@elev = Win32::Security.elevated_security?
+    @@version = `ver`.scan(/\d/).first.to_i
+
+    # No elevated_security? method for XP yet.
+    if @@version < 6
+      @@elevated = true
+    else
+      @@elevated = Win32::Security.elevated_security?
+    end
   end
 
   def setup
@@ -35,7 +38,7 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
   # Admin singleton methods
 
   def test_01_add_user
-    omit_unless(@@elev, "insufficient privileges - skipping")
+    omit_unless(@@elevated)
     assert_respond_to(Admin, :add_user)
     assert_nothing_raised{
       Admin.add_user(:name => 'foo', :password => 'a1b2c3D4')
@@ -43,7 +46,7 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
   end
 
   def test_02_config_user
-    omit_unless(@@elev, "insufficient privileges - skipping")
+    omit_unless(@@elevated)
     assert_respond_to(Admin, :configure_user)
     assert_nothing_raised{
       Admin.configure_user(
@@ -56,19 +59,19 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
   end
 
   def test_03_delete_user
-    omit_unless(@@elev, "insufficient privileges - skipping")
+    omit_unless(@@elevated)
     assert_respond_to(Admin, :delete_user)
     assert_nothing_raised{ Admin.delete_user('foo') }
   end
 
   def test_01_add_group
-    omit_unless(@@elev, "insufficient privileges - skipping")
+    omit_unless(@@elevated)
     assert_respond_to(Admin, :add_group)
     assert_nothing_raised{ Admin.add_group(:name => 'bar') }
   end
 
   def test_02_configure_group
-    omit_unless(@@elev, "insufficient privileges - skipping")
+    omit_unless(@@elevated)
     assert_respond_to(Admin, :configure_group)
     assert_nothing_raised{
        Admin.configure_group(:name => 'bar', :description => 'delete me')
@@ -76,7 +79,7 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
   end
 
   def test_03_delete_group
-    omit_unless(@@elev, "insufficient privileges - skipping")
+    omit_unless(@@elevated)
     assert_respond_to(Admin, :delete_group)
     assert_nothing_raised{ Admin.delete_group('bar') }
   end
@@ -120,11 +123,6 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
     assert_kind_of(User, Admin.get_user(@user_id, options))
   end
 
-  def test_get_user_with_no_options
-    assert_nothing_raised{ Admin.get_user(Etc.getlogin) }
-    assert_kind_of(User, Admin.get_user(Etc.getlogin))
-  end
-
   def test_get_user_expected_errors
     assert_raises(ArgumentError){ Admin.get_user }
   end
@@ -139,14 +137,6 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
     assert_kind_of(User, Admin.users(:localaccount => true).first)
   end
 
-  def test_users_with_block
-    array = []
-    assert_nothing_raised{
-       Admin.users(:localaccount => true){ |u| array << u }
-    }
-    assert_kind_of(User, array[0])
-  end
-
   def test_get_group_basic
     assert_respond_to(Admin, :get_group)
   end
@@ -166,11 +156,6 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
     assert_kind_of(Group, Admin.get_group(@group_name, :localaccount => true))
   end
 
-  def test_get_group_with_no_options
-    assert_nothing_raised{ Admin.get_group("Administrators") }
-    assert_kind_of(Group, Admin.get_group("Administrators"))
-  end
-
   def test_get_group_expected_errors
     assert_raise(ArgumentError){ Admin.get_group }
   end
@@ -185,14 +170,6 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
     assert_kind_of(Group, Admin.groups(:localaccount => true).first)
   end
 
-  def test_groups_with_block
-    array = []
-    assert_nothing_raised{
-       Admin.groups(:localaccount => true){ |g| array << g }
-    }
-    assert_kind_of(Group, array[0])
-  end
-
   # User class
 
   def test_user_instance_caption
@@ -348,5 +325,6 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
 
   def self.shutdown
     @@host = nil
+    @@elevated = nil
   end
 end