sys-admin 1.5.3-x86-mingw32

data/sys-admin.gemspec

@@ -0,0 +1,28 @@
+require 'rubygems'
+
+# Do not use this file directly. Build the gem via the Rake tasks.
+
+Gem::Specification.new do |spec|
+  spec.name      = 'sys-admin'
+  spec.version   = '1.5.3'
+  spec.author    = 'Daniel J. Berger'
+  spec.license   = 'Artistic 2.0'
+  spec.email     = 'djberg96@gmail.com'
+  spec.homepage  = 'http://www.github.com/djberg96/sysutils'
+  spec.summary   = 'A unified, cross platform replacement for the "etc" library.'
+  spec.test_file = 'test/test_sys_admin.rb'
+  spec.files     = Dir['**/*'].reject{ |f| f.include?('git') }
+
+  spec.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
+  spec.rubyforge_project = 'sysutils'
+	
+  spec.add_development_dependency('test-unit', '>= 2.1.1')
+
+  spec.description = <<-EOF
+    The sys-admin library is a unified, cross platform replacement for the
+    'etc' library that ships as part of the Ruby standard library. It
+    provides a common interface for all platforms, including MS Windows. In
+    addition, it provides an interface for adding, deleting and configuring
+    users on MS Windows.
+  EOF
+end

data/test/test_sys_admin.rb

@@ -0,0 +1,21 @@
+###############################################################################
+# 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.
+###############################################################################
+require 'rubygems'
+gem 'test-unit'
+require 'test/unit'
+
+if File::ALT_SEPARATOR
+  require 'test_sys_admin_windows'
+else
+  require 'test_sys_admin_unix'
+end
+
+class TC_Sys_Admin_All < Test::Unit::TestCase
+  def test_version
+    assert_equal('1.5.3', Sys::Admin::VERSION)
+  end
+end

data/test/test_sys_admin_unix.rb

@@ -0,0 +1,245 @@
+###############################################################################
+# 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/test_sys_admin_windows.rb

@@ -0,0 +1,333 @@
+###############################################################################
+# 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
+# before configuring or deleting them.
+# 
+# It is assumed that this test will be run via the 'rake test' task.
+###############################################################################
+require 'rubygems'
+gem 'test-unit'
+
+require 'test/unit'
+require 'sys/admin'
+require 'socket'
+include Sys
+
+class TC_Sys_Admin_Win32 < Test::Unit::TestCase
+   def self.startup
+      @@host = Socket.gethostname
+   end
+
+   def setup
+      @user       = User.new
+      @user_name  = 'Guest'
+      @user_id    = 501        # best guess, may fail
+      @group      = Group.new
+      @group_name = 'Guests'
+      @group_id   = 546        # best guess, may fail
+   end
+
+   # Admin singleton methods
+
+   def test_01_add_user
+      assert_respond_to(Admin, :add_user)
+      assert_nothing_raised{
+         Admin.add_user(:name => 'foo', :password => 'a1b2c3D4')
+      }
+   end
+
+   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_03_delete_user
+      assert_respond_to(Admin, :delete_user)
+      assert_nothing_raised{ Admin.delete_user('foo') }
+   end
+  
+   def test_01_add_group
+      assert_respond_to(Admin, :add_group)
+      assert_nothing_raised{ Admin.add_group(:name => 'bar') }
+   end
+   
+   def test_02_configure_group
+      assert_respond_to(Admin, :configure_group)
+      assert_nothing_raised{
+         Admin.configure_group(:name => 'bar', :description => 'delete me')
+      }
+   end
+   
+   def test_03_delete_group
+      assert_respond_to(Admin, :delete_group)
+      assert_nothing_raised{ Admin.delete_group('bar') }
+   end
+   
+   def test_get_login_basic
+      assert_respond_to(Admin, :get_login)
+      assert_nothing_raised{ Admin.get_login }
+   end
+
+   def test_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_basic
+      assert_respond_to(Admin, :get_user)
+   end
+  
+   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_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_basic
+      assert_respond_to(Admin, :users)
+      assert_nothing_raised{ Admin.users(:localaccount => true) }
+   end
+
+   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_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)
+      assert_respond_to(@user, :caption=)
+   end
+   
+   def test_user_instance_description
+      assert_respond_to(@user, :description)
+      assert_respond_to(@user, :description=)
+   end
+   
+   def test_user_instance_domain
+      assert_respond_to(@user, :domain)
+      assert_respond_to(@user, :domain=)
+   end
+   
+   def test_user_instance_password
+      assert_respond_to(@user, :password)
+      assert_respond_to(@user, :password=)
+   end
+   
+   def test_user_instance_full_name
+      assert_respond_to(@user, :full_name)
+      assert_respond_to(@user, :full_name=)
+   end
+   
+   def test_user_instance_name
+      assert_respond_to(@user, :name)
+      assert_respond_to(@user, :name=)
+   end
+   
+   def test_user_instance_sid
+      assert_respond_to(@user, :sid)
+      assert_respond_to(@user, :sid=)
+   end
+   
+   def test_user_instance_status
+      assert_respond_to(@user, :status)
+      assert_respond_to(@user, :status=)
+   end
+   
+   def test_user_instance_disabled
+      assert_respond_to(@user, :disabled?)
+      assert_respond_to(@user, :disabled=)
+   end
+   
+   def test_user_instance_local
+      assert_respond_to(@user, :local?)
+      assert_respond_to(@user, :local=)
+   end
+   
+   def test_user_instance_lockout
+      assert_respond_to(@user, :lockout?)
+      assert_respond_to(@user, :lockout=)
+   end
+   
+   def test_user_instance_password_changeable
+      assert_respond_to(@user, :password_changeable?)
+      assert_respond_to(@user, :password_changeable=)
+   end
+   
+   def test_user_instance_password_expires
+      assert_respond_to(@user, :password_expires?)
+      assert_respond_to(@user, :password_expires=)
+   end
+   
+   def test_user_instance_password_required
+      assert_respond_to(@user, :password_required?)
+      assert_respond_to(@user, :password_required=)
+   end
+   
+   def test_user_instance_account_type
+      assert_respond_to(@user, :account_type)
+      assert_respond_to(@user, :account_type=)
+   end
+
+   def test_user_instance_uid
+      assert_respond_to(@user, :uid)
+      assert_respond_to(@user, :uid=)
+   end
+   
+   def test_user_dir_basic
+      assert_respond_to(@user, :dir)
+      assert_respond_to(@user, :dir=)    
+   end
+   
+   def test_user_dir
+      assert_nothing_raised{ @user = Admin.get_user(@user_name, :localaccount => true) }
+      assert_kind_of([String, NilClass], @user.dir)
+   end
+   
+   # Group class
+   
+   def test_group_instance_caption
+      assert_respond_to(@group, :caption)
+      assert_respond_to(@group, :caption=)
+   end
+   
+   def test_group_instance_description
+      assert_respond_to(@group, :description)
+      assert_respond_to(@group, :description=)
+   end
+   
+   def test_group_instance_domain
+      assert_respond_to(@group, :domain)
+      assert_respond_to(@group, :domain=)
+   end
+   
+   def test_group_instance_install_date
+      assert_respond_to(@group, :install_date)
+      assert_respond_to(@group, :install_date=)
+   end
+   
+   def test_group_instance_name
+      assert_respond_to(@group, :name)
+      assert_respond_to(@group, :name)
+   end
+   
+   def test_group_instance_gid
+      assert_respond_to(@group, :gid)
+      assert_respond_to(@group, :gid=)
+   end
+   
+   def test_group_instance_status
+      assert_respond_to(@group, :status)
+      assert_respond_to(@group, :status=)
+   end
+   
+   def test_group_instance_sid
+      assert_respond_to(@group, :sid)
+      assert_respond_to(@group, :sid=)
+   end
+   
+   def test_group_instance_sid_type
+      assert_respond_to(@group, :sid_type)
+      assert_respond_to(@group, :sid_type=)
+   end
+   
+   def test_group_instance_local
+      assert_respond_to(@group, :local?)
+      assert_respond_to(@group, :local=)
+   end
+
+   def teardown
+      @user       = nil
+      @user_name  = nil
+      @user_id    = nil
+      @group      = nil
+      @group_name = nil
+      @group_id   = nil
+   end
+
+   def self.shutdown
+      @@host = nil
+   end
+end