sys-admin 1.4.4-x86-mswin32-60 → 1.5.0-x86-mswin32-60

data/sys-admin.gemspec

@@ -2,14 +2,14 @@ require 'rubygems'
 
 spec = Gem::Specification.new do |gem|
    gem.name         = 'sys-admin'
-   gem.version      = '1.4.4'
+   gem.version      = '1.5.0'
    gem.author       = 'Daniel J. Berger'
    gem.email        = 'djberg96@gmail.com'
    gem.homepage     = 'http://www.rubyforge.org/projects/sysutils'
    gem.platform     = Gem::Platform::RUBY
-   gem.summary      = 'A unified, cross platform replacement for the "etc" package.'
-   gem.description  = 'A unified, cross platform replacement for the "etc" package.'
-   gem.test_file    = 'test/tc_admin.rb'
+   gem.summary      = 'A unified, cross platform replacement for the "etc" library.'
+   gem.description  = 'A unified, cross platform replacement for the "etc" library.'
+   gem.test_file    = 'test/test_sys_admin.rb'
    gem.has_rdoc     = true
    gem.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
    gem.rubyforge_project = 'sysutils'

data/test/{tc_admin.rb → test_sys_admin.rb}

@@ -1,14 +1,21 @@
 ###############################################################################
-# tc_admin.rb
+# test_sys_admin.rb
 #
 # This exists mostly for the sake of the gemspec, so that it calls the right
 # test suite based on the platform.
 ###############################################################################
-$LOAD_PATH.unshift Dir.pwd
-$LOAD_PATH.unshift File.join(Dir.pwd, 'test')
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
 
 if File::ALT_SEPARATOR
-   require 'tc_windows'
+   require 'test_sys_admin_windows'
 else
-   require 'tc_unix'
+   require 'test_sys_admin_unix'
+end
+
+class TC_Sys_Admin_All < Test::Unit::TestCase
+   def test_version
+      assert_equal('1.5.0', Sys::Admin::VERSION)
+   end
 end

data/test/test_sys_admin_unix.rb

@@ -0,0 +1,246 @@
+###############################################################################
+# test_sys_admin_unix.rb
+#
+# Test suite for the Unix version of sys-admin. This test should be run
+# via the 'rake test' task.
+###############################################################################
+require 'test/unit'
+require 'sys/admin'
+include Sys
+
+class TC_Sys_Admin_Unix < Test::Unit::TestCase
+   def setup
+      @user = 'nobody'
+      @user_id  = 0
+
+      @group = 'sys'
+      @group_id = 3
+   end
+
+   ## Admin singleton methods
+
+   def test_get_login
+      assert_respond_to(Admin, :get_login)
+      assert_nothing_raised{ Admin.get_login }
+      assert_kind_of(String, Admin.get_login)
+   end
+
+   def test_get_user_basic
+      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))
+   end
+
+   def test_get_user_by_id
+      assert_kind_of(User, Admin.get_user(@user_id))
+   end
+
+   def test_get_user_expected_errors
+      assert_raise(ArgumentError){ Admin.get_user }
+      assert_raise(TypeError){ Admin.get_user([]) }
+      assert_raise(Admin::Error){ Admin.get_user('foofoofoo') }
+   end
+
+   def test_users_basic
+      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 } }
+   end
+
+   def test_users_expected_errors
+      assert_raise(ArgumentError){ Admin.users(@user_id) }
+   end
+
+   def test_get_group_basic
+      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))
+   end
+
+   def test_get_group_by_id
+      assert_kind_of(Group, Admin.get_group(@group_id))
+   end
+
+   def test_get_group_expected_errors
+      assert_raise(ArgumentError){ Admin.get_group }
+      assert_raise(TypeError){ Admin.get_group([]) }
+      assert_raise(Admin::Error){ Admin.get_group('foofoofoo') }
+   end
+
+   def test_groups_basic
+      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)
+   end
+
+   def test_groups_expected_errors
+      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
+      assert_respond_to(@user, :name)
+      assert_kind_of(String, @user.name)
+   end
+
+   def test_user_passwd
+      @user = Admin.users.first
+      assert_respond_to(@user, :passwd)
+      assert_kind_of(String, @user.passwd)
+   end
+
+   def test_user_uid
+      @user = Admin.users.first
+      assert_respond_to(@user, :uid)
+      assert_kind_of(Fixnum, @user.uid)
+   end
+
+   def test_user_gid
+      @user = Admin.users.first
+      assert_respond_to(@user, :gid)
+      assert_kind_of(Fixnum, @user.gid)
+   end
+
+   def test_user_dir
+      @user = Admin.users.first
+      assert_respond_to(@user, :dir)
+      assert_kind_of(String, @user.dir)
+   end
+
+   def test_user_shell
+      @user = Admin.users.first
+      assert_respond_to(@user, :shell)
+      assert_kind_of(String, @user.shell)
+   end
+
+   def test_user_gecos
+      @user = Admin.users.first
+      assert_respond_to(@user, :gecos)
+      assert_kind_of(String, @user.gecos)
+   end
+
+   def test_user_quota
+      @user = Admin.users.first
+      assert_respond_to(@user, :quota)
+      assert_true([Fixnum, NilClass].include?(@user.quota.class))
+   end
+
+   def test_user_age
+      @user = Admin.users.first
+      assert_respond_to(@user, :age)
+      assert_true([Fixnum, NilClass].include?(@user.age.class))
+   end
+
+   def test_user_access_class
+      @user = Admin.users.first
+      assert_respond_to(@user, :access_class)
+      assert_true([String, NilClass].include?(@user.access_class.class))
+   end
+
+   def test_user_comment
+      @user = Admin.users.first
+      assert_respond_to(@user, :comment)
+      assert_true([String, NilClass].include?(@user.comment.class))
+   end
+
+   def test_user_expire
+      @user = Admin.users.first
+      assert_respond_to(@user, :expire)
+      assert_true([Time, NilClass].include?(@user.expire.class))
+   end
+
+   def test_user_change
+      @user = Admin.users.first
+      assert_respond_to(@user, :change)
+      assert_true([Time, NilClass].include?(@user.change.class))
+   end
+
+   def test_user_login_time
+      @user = Admin.users.first
+      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
+      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
+      assert_respond_to(@user, :login_host)
+      assert_true([String, NilClass].include?(@user.login_host.class))
+   end
+
+   def test_user_groups
+      @user = Admin.users.first
+      assert_respond_to(@user, :groups)
+      assert_kind_of(Array, @user.groups)
+   end
+
+   ## Group Tests
+
+   def test_group_name
+      @group = Admin.groups.first
+      assert_respond_to(@group, :name)
+      assert_kind_of(String, @group.name)
+   end
+
+   def test_group_gid
+      @group = Admin.groups.first
+      assert_respond_to(@group, :gid)
+      assert_kind_of(Fixnum, @group.gid)
+   end
+
+   def test_group_members
+      @group = Admin.groups.first
+      assert_respond_to(@group, :members)
+      assert_kind_of(Array, @group.members)
+   end
+
+   def test_group_passwd
+      @group = Admin.groups.first
+      assert_respond_to(@group, :passwd)
+      assert_kind_of(String, @group.passwd)
+   end
+
+   def teardown
+      @user     = nil
+      @user_id  = nil
+      @group    = nil
+      @group_id = nil
+   end
+end

data/test/{tc_windows.rb → test_sys_admin_windows.rb}

@@ -1,5 +1,5 @@
 ###############################################################################
-# tc_windows.rb
+# test_sys_admin_windows.rb
 #
 # Test suite for the Win32 version of sys-admin.  Note that some of the tests
 # are numbered to ensure a certain order.  That way I can add test users
@@ -22,120 +22,159 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
 
    def setup
       @user       = User.new
-      @user_name  = 'guest'
+      @user_name  = 'Guest'
       @user_id    = 501        # best guess, may fail
       @group      = Group.new
-      @group_name = 'guests'
+      @group_name = 'Guests'
       @group_id   = 546        # best guess, may fail
    end
 
-   def test_version
-      assert_equal('1.4.4', Admin::VERSION)
-   end
-   
-   def test_01_add_local_user
-      assert_respond_to(Admin, :add_local_user)
-      assert_nothing_raised{ Admin.add_local_user('foo') }
-   end
-   
-   def test_add_global_user
-      assert_respond_to(Admin, :add_global_user)
-   end
-   
-   def test_02_config_local_user
-      assert_respond_to(Admin, :config_local_user)
+   # Admin singleton methods
+
+   def test_01_add_user
+      assert_respond_to(Admin, :add_user)
       assert_nothing_raised{
-         Admin.config_local_user("foo", {
-            :description => "delete me",
-            :fullname    => "fubar"
-         })
+         Admin.add_user(:name => 'foo', :password => 'a1b2c3D4')
       }
    end
-   
-   def test_config_global_user
-      assert_respond_to(Admin, :config_global_user)
-   end
-   
-   def test_03_delete_local_user
-      assert_respond_to(Admin, :delete_local_user)
-      assert_nothing_raised{ Admin.delete_local_user("foo") }
-   end
-   
-   def test_delete_global_user
-      assert_respond_to(Admin, :delete_global_user)
+
+   def test_02_config_user
+      assert_respond_to(Admin, :configure_user)
+      assert_nothing_raised{
+         Admin.configure_user(
+            :name        => 'foo',
+            :description => 'delete me',
+            :fullname    => 'fubar',
+            :password    => ['a1b2c3D4', 'd1c2b3A4']
+         )
+      }
    end
    
-   def test_01_add_local_group
-      assert_respond_to(Admin, :add_local_group)
-      assert_nothing_raised{ Admin.add_local_group("bar") }
+   def test_03_delete_user
+      assert_respond_to(Admin, :delete_user)
+      assert_nothing_raised{ Admin.delete_user('foo') }
    end
-   
-   def test_add_global_group
-      assert_respond_to(Admin, :add_global_group)
+  
+   def test_01_add_group
+      assert_respond_to(Admin, :add_group)
+      assert_nothing_raised{ Admin.add_group(:name => 'bar') }
    end
    
-   def test_02_config_local_group
-      assert_respond_to(Admin, :config_local_group)
+   def test_02_configure_group
+      assert_respond_to(Admin, :configure_group)
       assert_nothing_raised{
-         Admin.config_local_group('bar', {:description => 'delete me'})
+         Admin.configure_group(:name => 'bar', :description => 'delete me')
       }
    end
    
-   def test_config_global_group
-      assert_respond_to(Admin, :config_global_group)
-   end
-   
-   def test_03_delete_local_group
-      assert_respond_to(Admin, :delete_local_group)
-      assert_nothing_raised{ Admin.delete_local_group("bar") }
+   def test_03_delete_group
+      assert_respond_to(Admin, :delete_group)
+      assert_nothing_raised{ Admin.delete_group('bar') }
    end
    
-   def test_delete_global_group
-      assert_respond_to(Admin, :delete_global_group)
+   def test_get_login_basic
+      assert_respond_to(Admin, :get_login)
+      assert_nothing_raised{ Admin.get_login }
    end
 
    def test_get_login
-      assert_respond_to(Admin, :get_login)
-      assert_nothing_raised{ Admin.get_login }
       assert_kind_of(String, Admin.get_login)
    end
+
+   def test_get_login_expected_errors
+      assert_raise(ArgumentError){ Admin.get_login('foo') }
+   end
    
-   def test_get_user
+   def test_get_user_basic
       assert_respond_to(Admin, :get_user)
-      assert_raises(ArgumentError){ Admin.get_user }
    end
   
-   def test_get_user_local
-      assert_nothing_raised{ Admin.get_user(@user_name) }     
-      assert_nothing_raised{ Admin.get_user(@user_id) }     
-      assert_kind_of(User, Admin.get_user(@user_name))      
-      assert_kind_of(User, Admin.get_user(@user_id))      
+   def test_get_user_by_string
+      assert_nothing_raised{ Admin.get_user(@user_name, :localaccount => true) }     
+      assert_kind_of(User, Admin.get_user(@user_name, :localaccount => true))
+   end
+
+   def test_get_user_by_uid
+      assert_nothing_raised{ Admin.get_user(@user_id, :localaccount => true) }
+      assert_kind_of(User, Admin.get_user(@user_id, :localaccount => true))
    end
    
-   def test_get_user_remote
-      assert_nothing_raised{ Admin.get_user(@user_name, @@host) }
-      assert_nothing_raised{ Admin.get_user(@user_id, @@host) }
-      assert_kind_of(User, Admin.get_user(@user_name, @@host))
-      assert_kind_of(User, Admin.get_user(@user_id, @@host))
+   def test_get_user_by_string_with_options
+      options = {:host => @@host, :localaccount => true}
+      assert_nothing_raised{ Admin.get_user(@user_name, options) }
+      assert_kind_of(User, Admin.get_user(@user_name, options))
+   end
+
+   def test_get_user_by_uid_with_options
+      options = {:host => @@host, :localaccount => true}
+      assert_nothing_raised{ Admin.get_user(@user_id, options) }
+      assert_kind_of(User, Admin.get_user(@user_id, options))
+   end
+
+   def test_get_user_expected_errors
+      assert_raises(ArgumentError){ Admin.get_user }
    end
    
-   def test_users
+   def test_users_basic
       assert_respond_to(Admin, :users)
+      assert_nothing_raised{ Admin.users(:localaccount => true) }
    end
 
-   def test_users_local     
-      assert_nothing_raised{ Admin.users }      
-      assert_nothing_raised{ Admin.users{ |u| } }     
-      assert_nothing_raised{ Admin.users(nil) }
-      assert_nothing_raised{ Admin.users(nil){ |u| } }
-      assert_kind_of(Array, Admin.users)
-      assert_kind_of(User, Admin.users.first)
+   def test_users
+      assert_kind_of(Array, Admin.users(:localaccount => true))
+      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
+     
+   def test_get_group_by_name
+      assert_nothing_raised{ Admin.get_group(@group_name, :localaccount => true) }
+      assert_kind_of(Group, Admin.get_group(@group_name, :localaccount => true))
+   end
+
+   def test_get_group_by_gid
+      assert_nothing_raised{ Admin.get_group(@group_id, :localaccount => true) }
+      assert_kind_of(Group, Admin.get_group(@group_id, :localaccount => true))
    end
    
-   def test_users_remote
-      assert_nothing_raised{ Admin.users(@@host) }
-      assert_nothing_raised{ Admin.users(@@host){ |u| } }
+   def test_get_group_with_options
+      assert_nothing_raised{ Admin.get_group(@group_name, :localaccount => true) }
+      assert_kind_of(Group, Admin.get_group(@group_name, :localaccount => true))
+   end
+
+   def test_get_group_expected_errors
+      assert_raise(ArgumentError){ Admin.get_group }
+   end
+   
+   def test_groups_basic
+      assert_respond_to(Admin, :groups)
+      assert_nothing_raised{ Admin.groups(:localaccount => true) }
+   end
+
+   def test_groups
+      assert_kind_of(Array, Admin.groups(:localaccount => true))
+      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
       assert_respond_to(@user, :caption)
@@ -217,40 +256,7 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
       assert_respond_to(@user, :uid=)
    end
    
-   def test_get_group
-      assert_respond_to(Admin, :get_group)
-      assert_raises(ArgumentError){ Admin.get_group }
-   end
-     
-   def test_get_group_local     
-      assert_nothing_raised{ Admin.get_group(@group_name) }     
-      assert_kind_of(Group, Admin.get_group(@group_name))
-      assert_nothing_raised{ Admin.get_group(@group_id) }     
-      assert_kind_of(Group, Admin.get_group(@group_id))
-   end
-   
-   def test_get_group_remote
-      assert_nothing_raised{ Admin.get_group(@group_name, @@host) }
-      assert_kind_of(Group, Admin.get_group(@group_name, @@host))
-   end
-   
-   def test_groups
-      assert_respond_to(Admin, :groups)
-   end
-  
-   def test_groups_local      
-      assert_nothing_raised{ Admin.groups }     
-      assert_nothing_raised{ Admin.groups{ |g| } }      
-      assert_kind_of(Array, Admin.groups)     
-      assert_kind_of(Group, Admin.groups.first)     
-   end
-   
-   def test_groups_remote
-      assert_nothing_raised{ Admin.groups(@@host) }
-      assert_nothing_raised{ Admin.groups(@@host){ |g| } }
-      assert_kind_of(Array, Admin.groups(@@host))
-      assert_kind_of(Group, Admin.groups(@@host).first)
-   end
+   # Group class
    
    def test_group_instance_caption
       assert_respond_to(@group, :caption)