2001-05-18 18:38:52 -03:00
|
|
|
"""Test script for the grp module."""
|
|
|
|
|
|
|
|
import unittest
|
2002-07-23 16:04:11 -03:00
|
|
|
from test import test_support
|
2001-05-18 18:38:52 -03:00
|
|
|
|
2009-03-30 16:04:00 -03:00
|
|
|
grp = test_support.import_module('grp')
|
|
|
|
|
2001-05-18 18:38:52 -03:00
|
|
|
class GroupDatabaseTestCase(unittest.TestCase):
|
|
|
|
|
2003-04-23 16:50:24 -03:00
|
|
|
def check_value(self, value):
|
|
|
|
# check that a grp tuple has the entries and
|
|
|
|
# attributes promised by the docs
|
|
|
|
self.assertEqual(len(value), 4)
|
|
|
|
self.assertEqual(value[0], value.gr_name)
|
2010-01-24 12:58:36 -04:00
|
|
|
self.assertIsInstance(value.gr_name, basestring)
|
2003-04-23 16:50:24 -03:00
|
|
|
self.assertEqual(value[1], value.gr_passwd)
|
2010-01-24 12:58:36 -04:00
|
|
|
self.assertIsInstance(value.gr_passwd, basestring)
|
2003-04-23 16:50:24 -03:00
|
|
|
self.assertEqual(value[2], value.gr_gid)
|
2013-03-23 17:40:36 -03:00
|
|
|
self.assertIsInstance(value.gr_gid, (long, int))
|
2003-04-23 16:50:24 -03:00
|
|
|
self.assertEqual(value[3], value.gr_mem)
|
2010-01-24 12:58:36 -04:00
|
|
|
self.assertIsInstance(value.gr_mem, list)
|
2003-04-23 16:50:24 -03:00
|
|
|
|
2003-04-15 08:10:33 -03:00
|
|
|
def test_values(self):
|
|
|
|
entries = grp.getgrall()
|
2001-05-18 18:38:52 -03:00
|
|
|
|
2003-04-15 08:10:33 -03:00
|
|
|
for e in entries:
|
2003-04-23 16:50:24 -03:00
|
|
|
self.check_value(e)
|
2003-04-15 12:59:36 -03:00
|
|
|
|
2013-12-10 16:09:20 -04:00
|
|
|
def test_values_extended(self):
|
|
|
|
entries = grp.getgrall()
|
2008-01-22 21:18:27 -04:00
|
|
|
if len(entries) > 1000: # Huge group file (NIS?) -- skip the rest
|
2013-12-10 16:09:20 -04:00
|
|
|
self.skipTest('huge group file, extended test skipped')
|
2008-01-22 21:18:27 -04:00
|
|
|
|
2003-04-15 12:59:36 -03:00
|
|
|
for e in entries:
|
2003-04-23 16:50:24 -03:00
|
|
|
e2 = grp.getgrgid(e.gr_gid)
|
|
|
|
self.check_value(e2)
|
On Mac OS X pwd.getpwall() might return the tuples
('pgsql', '*', 252, []) and ('postgres', '*', 252, ['skip']),
but pwd.getgrgid(252) might return ('pgsql', '', 252, ['skip']).
Drop the test that tried to find a tuple similar to the one
returned from pwd.getgrgid() among those for the same gid returned
by pwd.getgrall(), as the only working definition of 'similar' seems
to be 'has the same gid'. This check can be done more directly.
This should fix SF bug #732783.
2003-05-05 17:37:33 -03:00
|
|
|
self.assertEqual(e2.gr_gid, e.gr_gid)
|
2010-12-14 12:26:30 -04:00
|
|
|
name = e.gr_name
|
|
|
|
if name.startswith('+') or name.startswith('-'):
|
|
|
|
# NIS-related entry
|
|
|
|
continue
|
|
|
|
e2 = grp.getgrnam(name)
|
2003-04-23 16:50:24 -03:00
|
|
|
self.check_value(e2)
|
2006-05-25 18:33:11 -03:00
|
|
|
# There are instances where getgrall() returns group names in
|
|
|
|
# lowercase while getgrgid() returns proper casing.
|
|
|
|
# Discovered on Ubuntu 5.04 (custom).
|
2010-12-14 12:26:30 -04:00
|
|
|
self.assertEqual(e2.gr_name.lower(), name.lower())
|
2001-05-18 18:38:52 -03:00
|
|
|
|
2003-04-15 08:10:33 -03:00
|
|
|
def test_errors(self):
|
|
|
|
self.assertRaises(TypeError, grp.getgrgid)
|
|
|
|
self.assertRaises(TypeError, grp.getgrnam)
|
|
|
|
self.assertRaises(TypeError, grp.getgrall, 42)
|
2001-05-18 18:38:52 -03:00
|
|
|
|
2003-04-15 08:10:33 -03:00
|
|
|
# try to get some errors
|
|
|
|
bynames = {}
|
|
|
|
bygids = {}
|
|
|
|
for (n, p, g, mem) in grp.getgrall():
|
2005-12-12 16:53:40 -04:00
|
|
|
if not n or n == '+':
|
|
|
|
continue # skip NIS entries etc.
|
2003-04-15 08:10:33 -03:00
|
|
|
bynames[n] = g
|
|
|
|
bygids[g] = n
|
|
|
|
|
|
|
|
allnames = bynames.keys()
|
|
|
|
namei = 0
|
|
|
|
fakename = allnames[namei]
|
|
|
|
while fakename in bynames:
|
2008-07-18 16:06:13 -03:00
|
|
|
chars = list(fakename)
|
2003-04-15 08:10:33 -03:00
|
|
|
for i in xrange(len(chars)):
|
|
|
|
if chars[i] == 'z':
|
|
|
|
chars[i] = 'A'
|
|
|
|
break
|
|
|
|
elif chars[i] == 'Z':
|
|
|
|
continue
|
|
|
|
else:
|
|
|
|
chars[i] = chr(ord(chars[i]) + 1)
|
|
|
|
break
|
|
|
|
else:
|
|
|
|
namei = namei + 1
|
|
|
|
try:
|
|
|
|
fakename = allnames[namei]
|
|
|
|
except IndexError:
|
|
|
|
# should never happen... if so, just forget it
|
|
|
|
break
|
2008-07-18 16:06:13 -03:00
|
|
|
fakename = ''.join(chars)
|
2003-04-15 08:10:33 -03:00
|
|
|
|
|
|
|
self.assertRaises(KeyError, grp.getgrnam, fakename)
|
2001-09-20 18:33:42 -03:00
|
|
|
|
2003-04-15 08:10:33 -03:00
|
|
|
# Choose a non-existent gid.
|
|
|
|
fakegid = 4127
|
|
|
|
while fakegid in bygids:
|
|
|
|
fakegid = (fakegid * 3) % 0x10000
|
|
|
|
|
|
|
|
self.assertRaises(KeyError, grp.getgrgid, fakegid)
|
|
|
|
|
|
|
|
def test_main():
|
2003-05-01 14:45:56 -03:00
|
|
|
test_support.run_unittest(GroupDatabaseTestCase)
|
2001-09-20 18:33:42 -03:00
|
|
|
|
|
|
|
if __name__ == "__main__":
|
|
|
|
test_main()
|