###############################################################################
# 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

   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_user_instance_uid
      assert_respond_to(@user, :uid)
      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
   
   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