sys-admin 1.3.1-mswin32 → 1.4.0-mswin32

data/sys-admin.gemspec

@@ -0,0 +1,38 @@
+require 'rubygems'
+
+spec = Gem::Specification.new do |gem|
+   gem.name         = 'sys-admin'
+   gem.version      = '1.4.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.has_rdoc     = true
+   gem.extra_rdoc_files  = ['CHANGES', 'README', 'MANIFEST']
+   gem.rubyforge_project = 'sysutils'
+	
+   files = Dir["doc/*"] + Dir["examples/*"]
+   files += Dir["test/*"] + Dir["[A-Z]*"]
+   files.delete_if{ |item| item.include?('CVS') }
+   gem.files = files
+end
+
+if $PROGRAM_NAME == __FILE__
+   if RUBY_PLATFORM.match('mswin')
+      spec.required_ruby_version = '>= 1.8.2'
+      spec.files += Dir["lib/sys/admin.rb"]
+      spec.platform = Gem::Platform::WIN32
+   else
+      spec.required_ruby_version = '>= 1.8.0'
+      spec.extensions = ['ext/extconf.rb']
+      spec.files += Dir["ext/*"]
+      spec.extra_rdoc_files << 'ext/admin.c'
+      spec.require_path = 'lib'
+   end
+	
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

data/test/tc_admin.rb

@@ -1,14 +1,14 @@
-###############################################################################
-# tc_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 Dir.pwd + "/test"
-
-if File::ALT_SEPARATOR
-   require "tc_win32"
-else
-   require "tc_unix"
-end
+###############################################################################
+# tc_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 Dir.pwd + "/test"
+
+if File::ALT_SEPARATOR
+   require "tc_windows"
+else
+   require "tc_unix"
+end

data/test/tc_unix.rb

@@ -0,0 +1,78 @@
+###############################################################################
+# tc_unix.rb
+#
+# Test suite for the Unix version of sys-admin.
+###############################################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /sys-admin.*/
+   require "fileutils"
+   Dir.chdir("..") if base == "test"
+   Dir.mkdir("sys") unless File.exists?("sys")
+   FileUtils.cp("ext/admin.so", "sys") if File.exists?("ext/admin.so")
+   $LOAD_PATH.unshift(Dir.pwd)
+end
+
+require 'test/unit'
+require 'sys/admin'
+include Sys
+
+class TC_Sys_Admin_Unix < Test::Unit::TestCase
+   def setup
+      @user    = "nobody"
+      @userid  = 0
+      @group   = "sys"
+      @groupid = 3
+   end
+
+   def test_version
+      assert_equal("1.4.0", Admin::VERSION)
+   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_user
+      assert_respond_to(Admin, :get_user)
+      assert_nothing_raised{ Admin.get_user(@user) }
+      assert_nothing_raised{ Admin.get_user(@userid) }
+      assert_kind_of(User, Admin.get_user(@user))
+      assert_kind_of(User, Admin.get_user(@userid))
+      assert_raises(AdminError){ Admin.get_user("foofoo") }
+   end
+
+   def test_users
+      assert_respond_to(Admin, :users)
+      assert_nothing_raised{ Admin.users }
+      assert_nothing_raised{ Admin.users{ |g| } }
+      assert_kind_of(Array, Admin.users)
+      assert_kind_of(User, Admin.users.first)
+   end
+
+   def test_get_group
+      assert_respond_to(Admin, :get_group)
+      assert_nothing_raised{ Admin.get_group(@group) }
+      assert_nothing_raised{ Admin.get_group(@groupid) }
+      assert_kind_of(Group, Admin.get_group(@group))
+      assert_kind_of(Group, Admin.get_group(@groupid))
+      assert_raises(AdminError){ Admin.get_group("foofoo") }
+   end
+
+   def test_groups
+      assert_respond_to(Admin, :groups)
+      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 teardown
+      @user    = nil
+      @userid  = nil
+      @group   = nil
+      @groupid = nil
+   end
+end

data/test/tc_windows.rb

@@ -0,0 +1,312 @@
+###############################################################################
+# tc_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.
+###############################################################################
+base = File.basename(Dir.pwd)
+
+if base == "test" || base =~ /sys-admin.*/
+   require "ftools"
+   Dir.chdir("..") if base == "test"
+   Dir.mkdir("sys") unless File.exists?("sys")
+   File.copy("lib/sys/admin.rb", "sys/admin.rb")
+   $LOAD_PATH.unshift(Dir.pwd)
+   Dir.chdir("test") rescue nil
+end
+
+require "test/unit"
+require "sys/admin"
+require "socket"
+include Sys
+
+class TC_Sys_Admin_Win32 < Test::Unit::TestCase
+   def setup
+      @host        = Socket.gethostname
+      @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
+
+   def test_version
+      assert_equal("1.4.0", 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)
+      assert_nothing_raised{
+         Admin.config_local_user("foo",{
+            :description => "delete me",
+            :fullname    => "fubar"
+         })
+      }
+   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)
+   end
+   
+   def test_01_add_local_group
+      assert_respond_to(Admin, :add_local_group)
+      assert_nothing_raised{ Admin.add_local_group("bar") }
+   end
+   
+   def test_add_global_group
+      assert_respond_to(Admin, :add_global_group)
+   end
+   
+   def test_02_config_local_group
+      assert_respond_to(Admin, :config_local_group)
+      assert_nothing_raised{
+         Admin.config_local_group("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") }
+   end
+   
+   def test_delete_global_group
+      assert_respond_to(Admin, :delete_global_group)
+   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_user
+      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))      
+   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))
+   end
+   
+   def test_users
+      assert_respond_to(Admin, :users)
+   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)
+   end
+   
+   def test_users_remote
+      assert_nothing_raised{ Admin.users(@host) }
+      assert_nothing_raised{ Admin.users(@host){ |u| } }
+   end
+   
+   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_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
+   
+   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
+      @host       = nil
+      @user       = nil
+      @user_name  = nil
+      @user_id    = nil
+      @group      = nil
+      @group_name = nil
+      @group_id   = nil
+   end
+end