sys-admin 1.6.1 → 1.6.2

data/lib/sys/admin/common.rb

@@ -34,7 +34,7 @@ module Sys
     public
 
     # The version of the sys-admin library.
-    VERSION = '1.6.1'
+    VERSION = '1.6.2'
 
     # Error typically raised if any of the Sys::Admin methods fail.
     class Error < StandardError; end

data/lib/windows/sys/admin.rb

@@ -154,6 +154,9 @@ module Sys
     # The user's id (RID).
     attr_accessor :uid
 
+    # The user's primary group ID.
+    attr_accessor :gid
+
     # The user's home directory
     attr_accessor :dir
 
@@ -196,26 +199,26 @@ module Sys
     # * User::SERVER_TRUST
     #
     def account_type=(type)
-       case type
-          when TEMP_DUPLICATE
-             @account_type = 'duplicate'
-          when NORMAL
-             @account_type = 'normal'
-          when INTERDOMAIN_TRUST
-             @account_type = 'interdomain_trust'
-          when WORKSTATION_TRUST
-             @account_type = 'workstation_trust'
-          when SERVER_TRUST
-             @account_type = 'server_trust'
-          else
-             @account_type = 'unknown'
-       end
+      case type
+        when TEMP_DUPLICATE
+          @account_type = 'duplicate'
+        when NORMAL
+          @account_type = 'normal'
+        when INTERDOMAIN_TRUST
+          @account_type = 'interdomain_trust'
+        when WORKSTATION_TRUST
+          @account_type = 'workstation_trust'
+        when SERVER_TRUST
+          @account_type = 'server_trust'
+        else
+          @account_type = 'unknown'
+      end
     end
 
     # Returns the SID type as a human readable string.
     #
     def sid_type
-       @sid_type
+      @sid_type
     end
 
     # Sets the SID (Security Identifier) type to +stype+, which can be
@@ -232,64 +235,64 @@ module Sys
     # * Admin::SidTypeComputer
     #
     def sid_type=(stype)
-       case stype
-          when Admin::SidTypeUser
-             @sid_type = 'user'
-          when Admin::SidTypeGroup
-             @sid_type = 'group'
-          when Admin::SidTypeDomain
-             @sid_type = 'domain'
-          when Admin::SidTypeAlias
-             @sid_type = 'alias'
-          when Admin::SidTypeWellKnownGroup
-             @sid_type = 'well_known_group'
-          when Admin::SidTypeDeletedAccount
-             @sid_type = 'deleted_account'
-          when Admin::SidTypeInvalid
-             @sid_type = 'invalid'
-          when Admin::SidTypeUnknown
-             @sid_type = 'unknown'
-          when Admin::SidTypeComputer
-             @sid_type = 'computer'
-          else
-             @sid_type = 'unknown'
-       end
+      case stype
+        when Admin::SidTypeUser
+          @sid_type = 'user'
+        when Admin::SidTypeGroup
+          @sid_type = 'group'
+        when Admin::SidTypeDomain
+          @sid_type = 'domain'
+        when Admin::SidTypeAlias
+          @sid_type = 'alias'
+        when Admin::SidTypeWellKnownGroup
+          @sid_type = 'well_known_group'
+        when Admin::SidTypeDeletedAccount
+          @sid_type = 'deleted_account'
+        when Admin::SidTypeInvalid
+          @sid_type = 'invalid'
+        when Admin::SidTypeUnknown
+          @sid_type = 'unknown'
+        when Admin::SidTypeComputer
+          @sid_type = 'computer'
+        else
+          @sid_type = 'unknown'
+      end
     end
 
     # Returns whether or not the account is disabled.
     #
     def disabled?
-       @disabled
+      @disabled
     end
 
     # Returns whether or not the account is local.
     #
     def local?
-       @local
+      @local
     end
 
     # Returns whether or not the account is locked out.
     #
     def lockout?
-       @lockout
+      @lockout
     end
 
     # Returns whether or not the password for the account is changeable.
     #
     def password_changeable?
-       @password_changeable
+      @password_changeable
     end
 
     # Returns whether or not the password for the account is changeable.
     #
     def password_expires?
-       @password_expires
+      @password_expires
     end
 
     # Returns whether or not the a password is required for the account.
     #
     def password_required?
-       @password_required
+      @password_required
     end
   end
 
@@ -297,7 +300,7 @@ module Sys
     extend FFI::Library
 
     # The version of the sys-admin library.
-    VERSION = '1.6.1'
+    VERSION = '1.6.2'
 
     # This is the error raised in the majority of cases if anything goes wrong
     # with any of the Sys::Admin methods.
@@ -358,13 +361,14 @@ module Sys
     end
 
     # An internal, private method for getting a list of groups for
-    # a particular user.
+    # a particular user. The first member is a list of group names,
+    # the second member is the primary group ID.
     #
     def self.get_groups(domain, user)
       array = []
-      adsi = WIN32OLE.connect("WinNT://#{domain}/#{user}")
+      adsi = WIN32OLE.connect("WinNT://#{domain}/#{user},user")
       adsi.groups.each{ |g| array << g.name }
-      array
+      [array, adsi.PrimaryGroupId]
     end
 
     # An internal, private method for getting a list of members for
@@ -721,6 +725,8 @@ module Sys
           next if usr != uid
         end
 
+        groups, primary_group = *get_groups(domain, user.name)
+
         user_object = User.new do |u|
           u.account_type        = user.accounttype
           u.caption             = user.caption
@@ -739,7 +745,8 @@ module Sys
           u.sid_type            = user.sidtype
           u.status              = user.status
           u.uid                 = uid
-          u.groups              = get_groups(domain, user.name)
+          u.gid                 = primary_group
+          u.groups              = groups
           u.dir                 = get_home_dir(user.name, options[:localaccount], domain)
         end
 

data/sys-admin.gemspec

@@ -1,10 +1,9 @@
-require 'rubygems'
-
 # Do not use this file directly. Build the gem via the Rake tasks.
+require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'sys-admin'
-  spec.version   = '1.6.1'
+  spec.version   = '1.6.2'
   spec.author    = 'Daniel J. Berger'
   spec.license   = 'Artistic 2.0'
   spec.email     = 'djberg96@gmail.com'

data/test/test_sys_admin.rb

@@ -14,6 +14,6 @@ end
 
 class TC_Sys_Admin_All < Test::Unit::TestCase
   test "version is set to expected value" do
-    assert_equal('1.6.1', Sys::Admin::VERSION)
+    assert_equal('1.6.2', Sys::Admin::VERSION)
   end
 end

data/test/test_sys_admin_windows.rb

@@ -89,232 +89,234 @@ class TC_Sys_Admin_Win32 < Test::Unit::TestCase
     assert_nothing_raised{ Admin.delete_group('bar') }
   end
 
-  def test_get_login_basic
+  test "get_login basic functionality" do
     assert_respond_to(Admin, :get_login)
     assert_nothing_raised{ Admin.get_login }
   end
 
-  def test_get_login
+  test "get_login returns a string" do
     assert_kind_of(String, Admin.get_login)
+    assert_true(Admin.get_login.size > 0)
   end
 
-  def test_get_login_expected_errors
+  test "get_login does not accept any arguments" do
     assert_raise(ArgumentError){ Admin.get_login('foo') }
   end
 
-  def test_get_user_basic
+  test "get_user basic functionality" do
     assert_respond_to(Admin, :get_user)
   end
 
-  def test_get_user_by_string
+  test "get_user with string argument works as expected" do
     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
+  test "get user with integer argument works as expected" do
     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
+  test "get_user method by string accepts a hash of options" do
     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
+  test "get_user method by uid accepts a hash of options" do
     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
+  test "get_user method requires an argument" do
     assert_raises(ArgumentError){ Admin.get_user }
   end
 
-  def test_users_basic
+  test "users method basic functionality" do
     assert_respond_to(Admin, :users)
     assert_nothing_raised{ Admin.users(:localaccount => true) }
   end
 
-  def test_users
+  test "users method returns an array of User objects" do
     assert_kind_of(Array, Admin.users(:localaccount => true))
     assert_kind_of(User, Admin.users(:localaccount => true).first)
   end
 
-  def test_get_group_basic
+  test "get_group basic functionality" do
     assert_respond_to(Admin, :get_group)
   end
 
-  def test_get_group_by_name
+  test "get_group method returns expected results with a string argument" do
     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
+  test "get_group method returns expected results with an integer argument" do
     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
+  # TODO: Update
+  test "get_group method accepts a hash of options" do
     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
+  test "get_group method requires an argument" do
     assert_raise(ArgumentError){ Admin.get_group }
   end
 
-  def test_groups_basic
+  test "get_groups method basic functionality" do
     assert_respond_to(Admin, :groups)
     assert_nothing_raised{ Admin.groups(:localaccount => true) }
   end
 
-  def test_groups
+  test "get_groups method returns an array of Group objects" do
     assert_kind_of(Array, Admin.groups(:localaccount => true))
     assert_kind_of(Group, Admin.groups(:localaccount => true).first)
   end
 
   # User class
 
-  def test_user_instance_caption
+  test "caption accessor for User class" do
     assert_respond_to(@user, :caption)
     assert_respond_to(@user, :caption=)
   end
 
-  def test_user_instance_description
+  test "description accessor for User class" do
     assert_respond_to(@user, :description)
     assert_respond_to(@user, :description=)
   end
 
-  def test_user_instance_domain
+  test "domain accessor for User class" do
     assert_respond_to(@user, :domain)
     assert_respond_to(@user, :domain=)
   end
 
-  def test_user_instance_password
+  test "password accessor for User class" do
     assert_respond_to(@user, :password)
     assert_respond_to(@user, :password=)
   end
 
-  def test_user_instance_full_name
+  test "full_name accessor for User class" do
     assert_respond_to(@user, :full_name)
     assert_respond_to(@user, :full_name=)
   end
 
-  def test_user_instance_name
+  test "name accessor for User class" do
     assert_respond_to(@user, :name)
     assert_respond_to(@user, :name=)
   end
 
-  def test_user_instance_sid
+  test "sid accessor for User class" do
     assert_respond_to(@user, :sid)
     assert_respond_to(@user, :sid=)
   end
 
-  def test_user_instance_status
+  test "status accessor for User class" do
     assert_respond_to(@user, :status)
     assert_respond_to(@user, :status=)
   end
 
-  def test_user_instance_disabled
+  test "disabled accessor for User class" do
     assert_respond_to(@user, :disabled?)
     assert_respond_to(@user, :disabled=)
   end
 
-  def test_user_instance_local
+  test "local accessor for User class" do
     assert_respond_to(@user, :local?)
     assert_respond_to(@user, :local=)
   end
 
-  def test_user_instance_lockout
+  test "lockout accessor for User class" do
     assert_respond_to(@user, :lockout?)
     assert_respond_to(@user, :lockout=)
   end
 
-  def test_user_instance_password_changeable
+  test "password_changeable accessor for User class" do
     assert_respond_to(@user, :password_changeable?)
     assert_respond_to(@user, :password_changeable=)
   end
 
-  def test_user_instance_password_expires
+  test "password_expires accessor for User class" do
     assert_respond_to(@user, :password_expires?)
     assert_respond_to(@user, :password_expires=)
   end
 
-  def test_user_instance_password_required
+  test "password_required accessor for User class" do
     assert_respond_to(@user, :password_required?)
     assert_respond_to(@user, :password_required=)
   end
 
-  def test_user_instance_account_type
+  test "account_type accessor for User class" do
     assert_respond_to(@user, :account_type)
     assert_respond_to(@user, :account_type=)
   end
 
-  def test_user_instance_uid
+  test "uid accessor for User class" do
     assert_respond_to(@user, :uid)
     assert_respond_to(@user, :uid=)
   end
 
-  def test_user_dir_basic
+  test "dir accessor for User class" do
     assert_respond_to(@user, :dir)
     assert_respond_to(@user, :dir=)
   end
 
-  def test_user_dir
+  test "dir method returns either a string or nil" do
     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
+  test "caption accessor for Group class" do
     assert_respond_to(@group, :caption)
     assert_respond_to(@group, :caption=)
   end
 
-  def test_group_instance_description
+  test "description accessor for Group class" do
     assert_respond_to(@group, :description)
     assert_respond_to(@group, :description=)
   end
 
-  def test_group_instance_domain
+  test "domain accessor for Group class" do
     assert_respond_to(@group, :domain)
     assert_respond_to(@group, :domain=)
   end
 
-  def test_group_instance_install_date
+  test "install_date accessor for Group class" do
     assert_respond_to(@group, :install_date)
     assert_respond_to(@group, :install_date=)
   end
 
-  def test_group_instance_name
+  test "name accessor for Group class" do
     assert_respond_to(@group, :name)
     assert_respond_to(@group, :name)
   end
 
-  def test_group_instance_gid
+  test "gid accessor for Group class" do
     assert_respond_to(@group, :gid)
     assert_respond_to(@group, :gid=)
   end
 
-  def test_group_instance_status
+  test "status accessor for Group class" do
     assert_respond_to(@group, :status)
     assert_respond_to(@group, :status=)
   end
 
-  def test_group_instance_sid
+  test "sid accessor for Group class" do
     assert_respond_to(@group, :sid)
     assert_respond_to(@group, :sid=)
   end
 
-  def test_group_instance_sid_type
+  test "sid_type accessor for Group class" do
     assert_respond_to(@group, :sid_type)
     assert_respond_to(@group, :sid_type=)
   end
 
-  def test_group_instance_local
+  test "local accessor for Group class" do
     assert_respond_to(@group, :local?)
     assert_respond_to(@group, :local=)
   end