1 import unittest

     2 from test import test_support

     3 

     4 import pwd

     5 

     6 class PwdTest(unittest.TestCase):

     7 

     8     def test_values(self):

     9         entries = pwd.getpwall()

    10         entriesbyname = {}

    11         entriesbyuid = {}

    12 

    13         for e in entries:

    14             self.assertEqual(len(e), 7)

    15             self.assertEqual(e[0], e.pw_name)

    16             self.assert_(isinstance(e.pw_name, basestring))

    17             self.assertEqual(e[1], e.pw_passwd)

    18             self.assert_(isinstance(e.pw_passwd, basestring))

    19             self.assertEqual(e[2], e.pw_uid)

    20             self.assert_(isinstance(e.pw_uid, int))

    21             self.assertEqual(e[3], e.pw_gid)

    22             self.assert_(isinstance(e.pw_gid, int))

    23             self.assertEqual(e[4], e.pw_gecos)

    24             self.assert_(isinstance(e.pw_gecos, basestring))

    25             self.assertEqual(e[5], e.pw_dir)

    26             self.assert_(isinstance(e.pw_dir, basestring))

    27             self.assertEqual(e[6], e.pw_shell)

    28             self.assert_(isinstance(e.pw_shell, basestring))

    29 

    30             # The following won't work, because of duplicate entries

    31             # for one uid

    32             #    self.assertEqual(pwd.getpwuid(e.pw_uid), e)

    33             # instead of this collect all entries for one uid

    34             # and check afterwards

    35             entriesbyname.setdefault(e.pw_name, []).append(e)

    36             entriesbyuid.setdefault(e.pw_uid, []).append(e)

    37 

    38         if len(entries) > 1000:  # Huge passwd file (NIS?) -- skip the rest

    39             return

    40 

    41         # check whether the entry returned by getpwuid()

    42         # for each uid is among those from getpwall() for this uid

    43         for e in entries:

    44             if not e[0] or e[0] == '+':

    45                 continue # skip NIS entries etc.

    46             self.assert_(pwd.getpwnam(e.pw_name) in entriesbyname[e.pw_name])

    47             self.assert_(pwd.getpwuid(e.pw_uid) in entriesbyuid[e.pw_uid])

    48 

    49     def test_errors(self):

    50         self.assertRaises(TypeError, pwd.getpwuid)

    51         self.assertRaises(TypeError, pwd.getpwnam)

    52         self.assertRaises(TypeError, pwd.getpwall, 42)

    53 

    54         # try to get some errors

    55         bynames = {}

    56         byuids = {}

    57         for (n, p, u, g, gecos, d, s) in pwd.getpwall():

    58             bynames[n] = u

    59             byuids[u] = n

    60 

    61         allnames = bynames.keys()

    62         namei = 0

    63         fakename = allnames[namei]

    64         while fakename in bynames:

    65             chars = list(fakename)

    66             for i in xrange(len(chars)):

    67                 if chars[i] == 'z':

    68                     chars[i] = 'A'

    69                     break

    70                 elif chars[i] == 'Z':

    71                     continue

    72                 else:

    73                     chars[i] = chr(ord(chars[i]) + 1)

    74                     break

    75             else:

    76                 namei = namei + 1

    77                 try:

    78                     fakename = allnames[namei]

    79                 except IndexError:

    80                     # should never happen... if so, just forget it

    81                     break

    82             fakename = ''.join(chars)

    83 

    84         self.assertRaises(KeyError, pwd.getpwnam, fakename)

    85 

    86         # Choose a non-existent uid.

    87         fakeuid = 4127

    88         while fakeuid in byuids:

    89             fakeuid = (fakeuid * 3) % 0x10000

    90 

    91         self.assertRaises(KeyError, pwd.getpwuid, fakeuid)

    92 

    93 def test_main():

    94     test_support.run_unittest(PwdTest)

    95 

    96 if __name__ == "__main__":

    97     test_main()