sys-admin 1.8.0-universal-mingw32

data/spec/sys_admin_unix_spec.rb

@@ -0,0 +1,262 @@
+###############################################################################
+# sys_admin_unix_rspec.rb
+#
+# Test suite for the Unix version of sys-admin. This test should be run
+# via the 'rake spec' task.
+###############################################################################
+require 'rspec'
+require 'sys/admin'
+
+RSpec.describe Sys::Admin, :unix do
+  let(:user)     { 'nobody' }
+  let(:user_id)  { 0 }
+  let(:group)    { 'sys' }
+  let(:group_id) { 3 }
+
+  context "singleton methods" do
+    describe "get_login" do
+      example "get_login basic functionality" do
+        expect(described_class).to respond_to(:get_login)
+        expect{ described_class.get_login }.not_to raise_error
+      end
+
+      example "get_login returns a string" do
+        expect(described_class.get_login).to be_kind_of(String)
+        expect(described_class.get_login.length).to be > 0
+      end
+    end
+
+    describe "get_user" do
+      example "get_user basic functionality" do
+        expect(described_class).to respond_to(:get_user)
+        expect{ described_class.get_user(user) }.not_to raise_error
+        expect{ described_class.get_user(user_id) }.not_to raise_error
+      end
+
+      example "get_user with a string argument works as expected" do
+        expect(described_class.get_user(user)).to be_kind_of(Sys::Admin::User)
+      end
+
+      example "get_user with an integer argument works as expected" do
+        expect(described_class.get_user(user_id)).to be_kind_of(Sys::Admin::User)
+      end
+
+      example "get_user requires one argument only" do
+        expect{ described_class.get_user }.to raise_error(ArgumentError)
+        expect{ described_class.get_user(user, user) }.to raise_error(ArgumentError)
+      end
+
+      example "get_user requires a string or integer argument" do
+        expect{ described_class.get_user([]) }.to raise_error(TypeError)
+      end
+
+      example "get_user raises an Error if the user cannot be found" do
+        expect{ described_class.get_user('foofoofoo') }.to raise_error(Sys::Admin::Error)
+      end
+    end
+
+    describe "users" do
+      example "users basic functionality" do
+        expect(described_class).to respond_to(:users)
+        expect{ described_class.users }.not_to raise_error
+      end
+
+      example "users returns an array of User objects" do
+        users = described_class.users
+        expect(users).to be_kind_of(Array)
+        expect(users).to all(be_kind_of(Sys::Admin::User))
+      end
+
+      example "users does not accept any arguments" do
+        expect{ described_class.users(user_id) }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "get_group" do
+      example "get_group basic functionality" do
+        expect(described_class).to respond_to(:get_group)
+        expect{ described_class.get_group(group) }.not_to raise_error
+        expect{ described_class.get_group(group_id) }.not_to raise_error
+      end
+
+      example "get_group accepts a string argument" do
+        expect(described_class.get_group(group)).to be_kind_of(Sys::Admin::Group)
+      end
+
+      example "get_group accepts an integer argument" do
+        expect(described_class.get_group(group_id)).to be_kind_of(Sys::Admin::Group)
+      end
+
+      example "get_group requires one argument only" do
+        expect{ described_class.get_group }.to raise_error(ArgumentError)
+        expect{ described_class.get_group(group_id, group_id) }.to raise_error(ArgumentError)
+      end
+
+      example "get_group raises a TypeError if an invalid type is passed" do
+        expect{ described_class.get_group([]) }.to raise_error(TypeError)
+      end
+
+      example "get_group raises an Error if the group cannot be found" do
+        expect{ described_class.get_group('foofoofoo') }.to raise_error(Sys::Admin::Error)
+      end
+    end
+
+    describe "groups" do
+      example "groups basic functionality" do
+        expect(described_class).to respond_to(:groups)
+        expect{ described_class.groups }.not_to raise_error
+      end
+
+      example "groups returns an array of Group objects" do
+        groups = described_class.groups
+        expect(groups).to be_kind_of(Array)
+        expect(groups).to all(be_kind_of(Sys::Admin::Group))
+      end
+
+      example "groups method does not accept any arguments" do
+        expect{ described_class.groups(group_id) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "instance methods" do
+    describe "User instance methods" do
+      example "user.name behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:name)
+        expect(user.name).to be_kind_of(String)
+      end
+
+      example "user.passwd behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:passwd)
+        expect(user.passwd).to be_kind_of(String)
+      end
+
+      example "user.uid behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:uid)
+        expect(user.uid).to be_kind_of(Integer)
+      end
+
+      example "user.gid behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:gid)
+        expect(user.gid).to be_kind_of(Integer)
+      end
+
+      example "user.dir behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:dir)
+        expect(user.dir).to be_kind_of(String)
+      end
+
+      example "user.shell behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:shell)
+        expect(user.shell).to be_kind_of(String)
+      end
+
+      example "user.gecos behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:gecos)
+        expect(user.gecos).to be_kind_of(String).or be_nil
+      end
+
+      example "user.quota behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:quota)
+        expect(user.quota).to be_kind_of(Integer).or be_nil
+      end
+
+      example "user.age behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:age)
+        expect(user.age).to be_kind_of(Integer).or be_nil
+      end
+
+      example "user.access behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:access_class)
+        expect(user.access_class).to be_kind_of(String).or be_nil
+      end
+
+      example "user.comment behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:comment)
+        expect(user.comment).to be_kind_of(String).or be_nil
+      end
+
+      example "user.expire behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:expire)
+        expect(user.expire).to be_kind_of(Time).or be_nil
+      end
+
+      example "user.change behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:change)
+        expect(user.change).to be_kind_of(Time).or be_nil
+      end
+
+      example "user.login_time behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:login_time)
+        expect(user.login_time).to be_kind_of(Time).or be_nil
+      end
+
+      example "user.login_device behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:login_device)
+        expect(user.login_device).to be_kind_of(String).or be_nil
+      end
+
+      example "user.login_host behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:login_host)
+        expect(user.login_host).to be_kind_of(String).or be_nil
+      end
+
+      example "user.groups behaves as expected" do
+        user = described_class.get_user(user_id)
+        expect(user).to respond_to(:groups)
+        expect(user.groups).to be_kind_of(Array)
+      end
+    end
+
+    describe "Group instance methods" do
+      example "group.name behaves as expected" do
+        group = described_class.get_group(group_id)
+        expect(group).to respond_to(:name)
+        expect(group.name).to be_kind_of(String)
+      end
+
+      example "group.gid behaves as expected" do
+        group = described_class.get_group(group_id)
+        expect(group).to respond_to(:gid)
+        expect(group.gid).to be_kind_of(Integer)
+      end
+
+      example "group.members behaves as expected" do
+        group = described_class.get_group(group_id)
+        expect(group).to respond_to(:members)
+        expect(group.members).to be_kind_of(Array)
+      end
+
+      example "group.passwd behaves as expected" do
+        group = described_class.get_group(group_id)
+        expect(group).to respond_to(:passwd)
+        expect(group.passwd).to be_kind_of(String)
+      end
+    end
+  end
+
+  context "ffi functions" do
+    example "ffi functions are private" do
+      methods = described_class.methods(false).map(&:to_s)
+      expect(methods).not_to include('getlogin')
+      expect(methods).not_to include('getlogin_r')
+      expect(methods).not_to include('strerror')
+    end
+  end
+end

data/spec/sys_admin_windows_spec.rb

@@ -0,0 +1,350 @@
+###############################################################################
+# sys_admin_windows_spec.rb
+#
+# Test suite for the MS Windows version of sys-admin. Note that some of the
+# are ordered. That way I can add test users before configuring or deleting
+# them.
+#
+# It is assumed that these specs will be run via the 'rake spec' task.
+###############################################################################
+require 'rspec'
+require 'sys/admin'
+require 'win32/security'
+require 'socket'
+
+RSpec.describe Sys::Admin, :windows do
+  let(:host) { Socket.gethostname }
+  let(:elevated) { Win32::Security.elevated_security? }
+
+  before do
+    @user       = Sys::Admin::User.new
+    @user_name  = 'Guest'
+    @user_id    = 501        # best guess, may fail
+    @group      = Sys::Admin::Group.new
+    @group_name = 'Guests'
+    @group_id   = 546        # best guess, may fail
+  end
+
+  describe "add, configure and delete user", :order => :defined do
+    before(:all) do
+      @local_user = "foo"
+    end
+
+    example "add user" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:add_user)
+      expect{ described_class.add_user(:name => @local_user, :password => 'a1b2c3D4') }.not_to raise_error
+      expect{ described_class.get_user(@local_user) }.not_to raise_error
+    end
+
+    example "configure user" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:configure_user)
+      expect{
+        described_class.configure_user(
+          :name        => @local_user,
+          :description => 'delete me',
+          :fullname    => 'fubar',
+          :password    => 'd1c2b3A4'
+        )
+      }.not_to raise_error
+      expect(described_class.get_user(@local_user).description).to eq('delete me')
+    end
+
+    example "delete user" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:delete_user)
+      expect{ described_class.delete_user(@local_user) }.not_to raise_error
+      expect{ described_class.get_user(@local_user) }.to raise_error(Sys::Admin::Error)
+    end
+  end
+
+  describe "add, configure and delete group", :order => :defined do
+    before(:all) do
+      @local_user = "foo"
+      @local_group = "bar"
+      described_class.add_user(:name => @local_user)
+    end
+
+    after(:all) do
+      described_class.delete_user(@local_user)
+    end
+
+    example "add group" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:add_group)
+      expect{ described_class.add_group(:name => @local_group) }.not_to raise_error
+    end
+
+    example "configure group" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:configure_group)
+      expect{ described_class.configure_group(:name => @local_group, :description => 'delete me') }.not_to raise_error
+    end
+
+    example "add group member" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:add_group_member)
+      expect{ described_class.add_group_member(@local_user, @local_group) }.not_to raise_error
+      expect(described_class.get_group(@local_group, :localaccount => true).members).to include(@local_user)
+    end
+
+    example "remove group member" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:remove_group_member)
+      expect{ described_class.remove_group_member(@local_user, @local_group) }.not_to raise_error
+    end
+
+    example "delete group" do
+      skip "requires elevated privileges" unless elevated
+      expect(described_class).to respond_to(:delete_group)
+      expect{ described_class.delete_group(@local_group) }.not_to raise_error
+    end
+  end
+
+  context "singleton methods" do
+    describe "get_login" do
+      example "get_login basic functionality" do
+        expect(described_class).to respond_to(:get_login)
+        expect{ described_class.get_login }.not_to raise_error
+      end
+
+      example "get_login returns a string" do
+        expect( described_class.get_login).to be_kind_of(String)
+        expect(described_class.get_login.size).to be > 0
+      end
+
+      example "get_login does not accept any arguments" do
+        expect{ described_class.get_login('foo') }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "get_user" do
+      example "get_user basic functionality" do
+        expect(described_class).to respond_to(:get_user)
+      end
+
+      example "get_user with string argument works as expected" do
+        expect{ described_class.get_user(@user_name, :localaccount => true) }.not_to raise_error
+        expect( described_class.get_user(@user_name, :localaccount => true)).to be_kind_of(Sys::Admin::User)
+      end
+
+      example "get user with integer argument works as expected" do
+        expect{ described_class.get_user(@user_id, :localaccount => true) }.not_to raise_error
+        expect( described_class.get_user(@user_id, :localaccount => true)).to be_kind_of(Sys::Admin::User)
+      end
+
+      example "get_user method by string accepts a hash of options" do
+        options = {:host => host, :localaccount => true}
+        expect{ described_class.get_user(@user_name, options) }.not_to raise_error
+        expect( described_class.get_user(@user_name, options)).to be_kind_of(Sys::Admin::User)
+      end
+
+      example "get_user method by uid accepts a hash of options" do
+        options = {:host => host, :localaccount => true}
+        expect{ described_class.get_user(@user_id, options) }.not_to raise_error
+        expect( described_class.get_user(@user_id, options)).to be_kind_of(Sys::Admin::User)
+      end
+
+      example "get_user method requires an argument" do
+        expect{ described_class.get_user }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "users" do
+      example "users method basic functionality" do
+        expect(described_class).to respond_to(:users)
+        expect{ described_class.users(:localaccount => true) }.not_to raise_error
+      end
+
+      example "users method returns an array of User objects" do
+        users = described_class.users(:localaccount => true)
+        expect(users).to be_kind_of(Array)
+        expect(users).to all(be_kind_of(Sys::Admin::User))
+      end
+    end
+
+    describe "get_group" do
+      example "get_group basic functionality" do
+        expect(described_class).to respond_to(:get_group)
+      end
+
+      example "get_group method returns expected results with a string argument" do
+        expect{ described_class.get_group(@group_name, :localaccount => true) }.not_to raise_error
+        expect(described_class.get_group(@group_name, :localaccount => true)).to be_kind_of(Sys::Admin::Group)
+      end
+
+      example "get_group method returns expected results with an integer argument" do
+        expect{ described_class.get_group(@group_id, :localaccount => true) }.not_to raise_error
+        expect(described_class.get_group(@group_id, :localaccount => true)).to be_kind_of(Sys::Admin::Group)
+      end
+
+      example "get_group method accepts a hash of options" do
+        options = {:host => host, :localaccount => true}
+        expect{ described_class.get_group(@group_name, options) }.not_to raise_error
+        expect(described_class.get_group(@group_name, options)).to be_kind_of(Sys::Admin::Group)
+      end
+
+      example "get_group method requires an argument" do
+        expect{ described_class.get_group }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "groups" do
+      example "groups method basic functionality" do
+        expect(described_class).to respond_to(:groups)
+        expect{ described_class.groups(:localaccount => true) }.not_to raise_error
+      end
+
+      example "groups method returns an array of Group objects" do
+        groups = described_class.groups(:localaccount => true)
+        expect(groups).to be_kind_of(Array)
+        expect(groups).to all(be_kind_of(Sys::Admin::Group))
+      end
+    end
+  end
+
+  context "User class" do
+    example "caption accessor for User class" do
+      expect(@user).to respond_to(:caption)
+      expect(@user).to respond_to(:caption=)
+    end
+
+    example "description accessor for User class" do
+      expect(@user).to respond_to(:description)
+      expect(@user).to respond_to(:description=)
+    end
+
+    example "domain accessor for User class" do
+      expect(@user).to respond_to(:domain)
+      expect(@user).to respond_to(:domain=)
+    end
+
+    example "password accessor for User class" do
+      expect(@user).to respond_to(:password)
+      expect(@user).to respond_to(:password=)
+    end
+
+    example "full_name accessor for User class" do
+      expect(@user).to respond_to(:full_name)
+      expect(@user).to respond_to(:full_name=)
+    end
+
+    example "name accessor for User class" do
+      expect(@user).to respond_to(:name)
+      expect(@user).to respond_to(:name=)
+    end
+
+    example "sid accessor for User class" do
+      expect(@user).to respond_to(:sid)
+      expect(@user).to respond_to(:sid=)
+    end
+
+    example "status accessor for User class" do
+      expect(@user).to respond_to(:status)
+      expect(@user).to respond_to(:status=)
+    end
+
+    example "disabled accessor for User class" do
+      expect(@user).to respond_to(:disabled?)
+      expect(@user).to respond_to(:disabled=)
+    end
+
+    example "local accessor for User class" do
+      expect(@user).to respond_to(:local?)
+      expect(@user).to respond_to(:local=)
+    end
+
+    example "lockout accessor for User class" do
+      expect(@user).to respond_to(:lockout?)
+      expect(@user).to respond_to(:lockout=)
+    end
+
+    example "password_changeable accessor for User class" do
+      expect(@user).to respond_to(:password_changeable?)
+      expect(@user).to respond_to(:password_changeable=)
+    end
+
+    example "password_expires accessor for User class" do
+      expect(@user).to respond_to(:password_expires?)
+      expect(@user).to respond_to(:password_expires=)
+    end
+
+    example "password_required accessor for User class" do
+      expect(@user).to respond_to(:password_required?)
+      expect(@user).to respond_to(:password_required=)
+    end
+
+    example "account_type accessor for User class" do
+      expect(@user).to respond_to(:account_type)
+      expect(@user).to respond_to(:account_type=)
+    end
+
+    example "uid accessor for User class" do
+      expect(@user).to respond_to(:uid)
+      expect(@user).to respond_to(:uid=)
+    end
+
+    example "dir accessor for User class" do
+      expect(@user).to respond_to(:dir)
+      expect(@user).to respond_to(:dir=)
+    end
+
+    example "dir method returns either a string or nil" do
+      expect{ @user = described_class.get_user(@user_name, :localaccount => true) }.not_to raise_error
+      expect(@user.dir).to be_kind_of(String).or be_kind_of(NilClass)
+    end
+  end
+
+  context "Group class" do
+    example "caption accessor for Group class" do
+      expect(@group).to respond_to(:caption)
+      expect(@group).to respond_to(:caption=)
+    end
+
+    example "description accessor for Group class" do
+      expect(@group).to respond_to(:description)
+      expect(@group).to respond_to(:description=)
+    end
+
+    example "domain accessor for Group class" do
+      expect(@group).to respond_to(:domain)
+      expect(@group).to respond_to(:domain=)
+    end
+
+    example "install_date accessor for Group class" do
+      expect(@group).to respond_to(:install_date)
+      expect(@group).to respond_to(:install_date=)
+    end
+
+    example "name accessor for Group class" do
+      expect(@group).to respond_to(:name)
+      expect(@group).to respond_to(:name)
+    end
+
+    example "gid accessor for Group class" do
+      expect(@group).to respond_to(:gid)
+      expect(@group).to respond_to(:gid=)
+    end
+
+    example "status accessor for Group class" do
+      expect(@group).to respond_to(:status)
+      expect(@group).to respond_to(:status=)
+    end
+
+    example "sid accessor for Group class" do
+      expect(@group).to respond_to(:sid)
+      expect(@group).to respond_to(:sid=)
+    end
+
+    example "sid_type accessor for Group class" do
+      expect(@group).to respond_to(:sid_type)
+      expect(@group).to respond_to(:sid_type=)
+    end
+
+    example "local accessor for Group class" do
+      expect(@group).to respond_to(:local?)
+      expect(@group).to respond_to(:local=)
+    end
+  end
+end